fix(webpack/ast): Fix span of null literals (#2925)

swc_webpack_ast:
 - Preserve original spans for injected `null` literals

crates/swc_webpack_ast/src/reducer.rs

@@ -4,7 +4,7 @@ use swc_common::{
     collections::AHashSet,
     pass::{Repeat, Repeated},
     util::take::Take,
-    Mark, SyntaxContext, DUMMY_SP,
+    Mark, Span, SyntaxContext, DUMMY_SP,
 };
 use swc_ecma_ast::*;
 use swc_ecma_utils::{ident::IdentLike, Id, IsEmpty, StmtLike, StmtOrModuleItem};
@@ -509,7 +509,7 @@ impl VisitMut for ReduceAst {
         match e {
             Expr::Seq(seq) => {
                 if seq.exprs.is_empty() {
-                    *e = null_expr();
+                    *e = null_expr(seq.span);
                     return;
                 }
 
@@ -530,7 +530,8 @@ impl VisitMut for ReduceAst {
                     return;
                 }
 
-                *e = null_expr();
+                *e = null_expr(i.span);
+                return;
             }
 
             Expr::Member(MemberExpr {
@@ -559,7 +560,7 @@ impl VisitMut for ReduceAst {
                 if let Some(arg) = expr.arg.take() {
                     *e = *arg;
                 } else {
-                    *e = null_expr();
+                    *e = null_expr(expr.span);
                     return;
                 }
             }
@@ -747,7 +748,7 @@ impl VisitMut for ReduceAst {
                 }
 
                 if el.opening.attrs.is_empty() && el.children.is_empty() {
-                    *e = null_expr();
+                    *e = null_expr(el.span);
                     return;
                 }
             }
@@ -780,19 +781,20 @@ impl VisitMut for ReduceAst {
                     && function.params.is_empty()
                     && function.body.is_empty()
                 {
-                    *e = null_expr();
+                    *e = null_expr(function.span);
                     self.changed = true;
                     return;
                 }
             }
 
             Expr::Arrow(ArrowExpr {
+                span,
                 params,
                 body: BlockStmtOrExpr::BlockStmt(body),
                 ..
             }) => {
                 if !self.preserve_fn && params.is_empty() && body.is_empty() {
-                    *e = null_expr();
+                    *e = null_expr(*span);
                     self.changed = true;
                     return;
                 }
@@ -812,14 +814,15 @@ impl VisitMut for ReduceAst {
             }
 
             Expr::Call(CallExpr {
+                span,
                 callee: ExprOrSuper::Super(..),
                 args,
                 ..
             }) => {
                 self.changed = true;
                 let exprs: Vec<_> = args.take().into_iter().map(|arg| arg.expr).collect();
                 if exprs.is_empty() {
-                    *e = null_expr();
+                    *e = null_expr(*span);
                     return;
                 }
                 let seq = Expr::Seq(SeqExpr {
@@ -942,7 +945,7 @@ impl VisitMut for ReduceAst {
 
         self.ignore_expr(&mut s.test);
         if s.test.is_invalid() {
-            s.test = Box::new(null_expr());
+            s.test = Box::new(null_expr(s.span));
         }
     }
 
@@ -1665,7 +1668,7 @@ impl VisitMut for ReduceAst {
                 self.ignore_expr(&mut ap.right);
 
                 if ap.right.is_invalid() {
-                    ap.right = Box::new(null_expr());
+                    ap.right = Box::new(null_expr(ap.span));
                 }
             }
         }
@@ -1693,7 +1696,7 @@ impl VisitMut for ReduceAst {
         }
 
         if had_init && v.init.is_none() && matches!(self.var_decl_kind, Some(VarDeclKind::Const)) {
-            v.init = Some(Box::new(null_expr()));
+            v.init = Some(Box::new(null_expr(v.span)));
         }
     }
 }
@@ -1766,8 +1769,8 @@ fn left_most(e: &Expr) -> Option<Ident> {
     }
 }
 
-fn null_expr() -> Expr {
-    Expr::Lit(Lit::Null(Null { span: DUMMY_SP }))
+fn null_expr(span: Span) -> Expr {
+    Expr::Lit(Lit::Null(Null { span }))
 }
 
 fn can_remove(e: &Expr) -> bool {

crates/swc_webpack_ast/tests/fixture/css-escape/1/input.js

@@ -0,0 +1,106 @@
+/*! https://mths.be/cssescape v1.5.1 by @mathias | MIT license */
+; (function (root, factory) {
+    // https://github.com/umdjs/umd/blob/master/returnExports.js
+    if (typeof exports == 'object') {
+        // For Node.js.
+        module.exports = factory(root);
+    } else if (typeof define == 'function' && define.amd) {
+        // For AMD. Register as an anonymous module.
+        define([], factory.bind(root, root));
+    } else {
+        // For browser globals (not exposing the function separately).
+        factory(root);
+    }
+}(typeof global != 'undefined' ? global : this, function (root) {
+
+    if (root.CSS && root.CSS.escape) {
+        return root.CSS.escape;
+    }
+
+    // https://drafts.csswg.org/cssom/#serialize-an-identifier
+    var cssEscape = function (value) {
+        if (arguments.length == 0) {
+            throw new TypeError('`CSS.escape` requires an argument.');
+        }
+        var string = String(value);
+        var length = string.length;
+        var index = -1;
+        var codeUnit;
+        var result = '';
+        var firstCodeUnit = string.charCodeAt(0);
+        while (++index < length) {
+            codeUnit = string.charCodeAt(index);
+            // Note: there’s no need to special-case astral symbols, surrogate
+            // pairs, or lone surrogates.
+
+            // If the character is NULL (U+0000), then the REPLACEMENT CHARACTER
+            // (U+FFFD).
+            if (codeUnit == 0x0000) {
+                result += '\uFFFD';
+                continue;
+            }
+
+            if (
+                // If the character is in the range [\1-\1F] (U+0001 to U+001F) or is
+                // U+007F, […]
+                (codeUnit >= 0x0001 && codeUnit <= 0x001F) || codeUnit == 0x007F ||
+                // If the character is the first character and is in the range [0-9]
+                // (U+0030 to U+0039), […]
+                (index == 0 && codeUnit >= 0x0030 && codeUnit <= 0x0039) ||
+                // If the character is the second character and is in the range [0-9]
+                // (U+0030 to U+0039) and the first character is a `-` (U+002D), […]
+                (
+                    index == 1 &&
+                    codeUnit >= 0x0030 && codeUnit <= 0x0039 &&
+                    firstCodeUnit == 0x002D
+                )
+            ) {
+                // https://drafts.csswg.org/cssom/#escape-a-character-as-code-point
+                result += '\\' + codeUnit.toString(16) + ' ';
+                continue;
+            }
+
+            if (
+                // If the character is the first character and is a `-` (U+002D), and
+                // there is no second character, […]
+                index == 0 &&
+                length == 1 &&
+                codeUnit == 0x002D
+            ) {
+                result += '\\' + string.charAt(index);
+                continue;
+            }
+
+            // If the character is not handled by one of the above rules and is
+            // greater than or equal to U+0080, is `-` (U+002D) or `_` (U+005F), or
+            // is in one of the ranges [0-9] (U+0030 to U+0039), [A-Z] (U+0041 to
+            // U+005A), or [a-z] (U+0061 to U+007A), […]
+            if (
+                codeUnit >= 0x0080 ||
+                codeUnit == 0x002D ||
+                codeUnit == 0x005F ||
+                codeUnit >= 0x0030 && codeUnit <= 0x0039 ||
+                codeUnit >= 0x0041 && codeUnit <= 0x005A ||
+                codeUnit >= 0x0061 && codeUnit <= 0x007A
+            ) {
+                // the character itself
+                result += string.charAt(index);
+                continue;
+            }
+
+            // Otherwise, the escaped character.
+            // https://drafts.csswg.org/cssom/#escape-a-character
+            result += '\\' + string.charAt(index);
+
+        }
+        return result;
+    };
+
+    if (!root.CSS) {
+        root.CSS = {};
+    }
+
+    root.CSS.escape = cssEscape;
+    return cssEscape;
+
+}));

crates/swc_webpack_ast/tests/fixture/css-escape/1/output.js

@@ -0,0 +1,2 @@
+if (null) module.exports;
+else if (define, define.amd) define(null, null);