Bump swc (#8686)

mischnic · web-flow · commit 426852f01f00 · 2022-12-14T08:15:28.000-08:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/packages/core/integration-tests/test/integration/transpilation-invalid/index.js b/packages/core/integration-tests/test/integration/transpilation-invalid/index.js
@@ -1,3 +1,5 @@
+/* @jsx h */
+
 const Boom = () => {
   const littleBoom = ['hello', 'world']
   return <div>{...littleBoom.map(el => el)}</div>
diff --git a/packages/core/integration-tests/test/transpilation.js b/packages/core/integration-tests/test/transpilation.js
@@ -411,20 +411,20 @@ describe('transpilation', function () {
                 {
                   message: null,
                   start: {
-                    column: 15,
-                    line: 3,
+                    column: 1,
+                    line: 1,
                   },
                   end: {
-                    column: 43,
-                    line: 3,
+                    column: 12,
+                    line: 1,
                   },
                 },
               ],
               filePath: source,
             },
           ],
           hints: null,
-          message: 'Spread children are not supported in React.',
+          message: 'pragma cannot be set when runtime is automatic',
           origin: '@parcel/transformer-js',
         },
         {
@@ -435,11 +435,11 @@ describe('transpilation', function () {
                   message: null,
                   start: {
                     column: 4,
-                    line: 7,
+                    line: 9,
                   },
                   end: {
                     column: 4,
-                    line: 7,
+                    line: 9,
                   },
                 },
               ],
diff --git a/packages/transformers/js/core/Cargo.toml b/packages/transformers/js/core/Cargo.toml
@@ -8,9 +8,9 @@ edition = "2018"
 crate-type = ["rlib"]
 
 [dependencies]
-swc_ecmascript = { version = "0.205.17", features = ["parser", "transforms", "module", "optimization", "react", "typescript", "utils", "visit", "codegen", "utils", "preset_env"] }
-swc_common = { version = "0.29.8", features = ["tty-emitter", "sourcemap"] }
-swc_atoms = "0.4.21"
+swc_ecmascript = { version = "0.206.19", features = ["parser", "transforms", "module", "optimization", "react", "typescript", "utils", "visit", "codegen", "utils", "preset_env"] }
+swc_common = { version = "0.29.23", features = ["tty-emitter", "sourcemap"] }
+swc_atoms = "0.4.29"
 indoc = "1.0.3"
 serde = "1.0.123"
 serde_bytes = "0.11.5"
diff --git a/packages/transformers/js/core/src/dependency_collector.rs b/packages/transformers/js/core/src/dependency_collector.rs
@@ -231,7 +231,7 @@ impl<'a> DependencyCollector<'a> {
 
 fn rewrite_require_specifier(node: ast::CallExpr) -> ast::CallExpr {
   if let Some(arg) = node.args.get(0) {
-    if let Some((value, _)) = match_str(&*arg.expr) {
+    if let Some((value, _)) = match_str(&arg.expr) {
       if value.starts_with("node:") {
         // create_require will take care of replacing the node: prefix...
         return create_require(value);
@@ -474,7 +474,7 @@ impl<'a> Fold for DependencyCollector<'a> {
               // Promise.resolve(require('foo'))
               if match_member_expr(member, vec!["Promise", "resolve"], self.decls) {
                 if let Some(expr) = node.args.get(0) {
-                  if match_require(&*expr.expr, self.decls, Mark::fresh(Mark::root())).is_some() {
+                  if match_require(&expr.expr, self.decls, Mark::fresh(Mark::root())).is_some() {
                     self.in_promise = true;
                     let node = node.fold_children_with(self);
                     self.in_promise = was_in_promise;
@@ -580,7 +580,7 @@ impl<'a> Fold for DependencyCollector<'a> {
         };
         let mut node = node.clone();
 
-        let (specifier, span) = if let Some(s) = self.match_new_url(&*arg.expr, self.decls) {
+        let (specifier, span) = if let Some(s) = self.match_new_url(&arg.expr, self.decls) {
           s
         } else if let Lit(ast::Lit::Str(str_)) = &*arg.expr {
           let (msg, docs) = if kind == DependencyKind::ServiceWorker {
@@ -626,7 +626,7 @@ impl<'a> Fold for DependencyCollector<'a> {
         return node;
       }
 
-      if let Some((specifier, span)) = match_str(&*arg.expr) {
+      if let Some((specifier, span)) = match_str(&arg.expr) {
         // require() calls aren't allowed in scripts, flag as an error.
         if kind == DependencyKind::Require && self.config.source_type == SourceType::Script {
           self.add_script_error(node.span);
@@ -750,7 +750,7 @@ impl<'a> Fold for DependencyCollector<'a> {
 
     if let Some(args) = &node.args {
       if !args.is_empty() {
-        let (specifier, span) = if let Some(s) = self.match_new_url(&*args[0].expr, self.decls) {
+        let (specifier, span) = if let Some(s) = self.match_new_url(&args[0].expr, self.decls) {
           s
         } else if let Lit(ast::Lit::Str(str_)) = &*args[0].expr {
           let constructor = match &*node.callee {
@@ -916,7 +916,7 @@ impl<'a> DependencyCollector<'a> {
             if let ast::Expr::Ident(id) = &**callee {
               if id.to_id() == resolve_id {
                 if let Some(arg) = call.args.get(0) {
-                  if match_require(&*arg.expr, self.decls, Mark::fresh(Mark::root())).is_some() {
+                  if match_require(&arg.expr, self.decls, Mark::fresh(Mark::root())).is_some() {
                     let was_in_promise = self.in_promise;
                     self.in_promise = true;
                     let node = node.fold_children_with(self);
@@ -1151,13 +1151,13 @@ impl<'a> DependencyCollector<'a> {
 
       if let Some(args) = &new.args {
         let (specifier, span) = if let Some(arg) = args.get(0) {
-          match_str(&*arg.expr)?
+          match_str(&arg.expr)?
         } else {
           return None;
         };
 
         if let Some(arg) = args.get(1) {
-          if self.is_import_meta_url(&*arg.expr) {
+          if self.is_import_meta_url(&arg.expr) {
             return Some((specifier, span));
           }
         }
@@ -1363,7 +1363,7 @@ fn match_worker_type(expr: Option<&ast::ExprOrSpread>) -> (SourceType, Option<as
             _ => return true,
           };
 
-          let v = if let Some((v, _)) = match_str(&*kv.value) {
+          let v = if let Some((v, _)) = match_str(&kv.value) {
             v
           } else {
             return true;
diff --git a/packages/transformers/js/core/src/fs.rs b/packages/transformers/js/core/src/fs.rs
@@ -53,7 +53,7 @@ impl<'a> Fold for InlineFS<'a> {
         if let Some((source, specifier)) = self.match_module_reference(expr) {
           if &source == "fs" && &specifier == "readFileSync" {
             if let Some(arg) = call.args.get(0) {
-              if let Some(res) = self.evaluate_fs_arg(&*arg.expr, call.args.get(1), call.span) {
+              if let Some(res) = self.evaluate_fs_arg(&arg.expr, call.args.get(1), call.span) {
                 return res;
               }
             }
@@ -90,7 +90,7 @@ impl<'a> InlineFS<'a> {
           _ => return None,
         };
 
-        if let Some(source) = self.collect.match_require(&*member.obj) {
+        if let Some(source) = self.collect.match_require(&member.obj) {
           return Some((source, prop));
         }
 
@@ -127,7 +127,7 @@ impl<'a> InlineFS<'a> {
           Ok(path) => path,
           Err(_err) => return None,
         };
-        if !path.starts_with(&self.project_root) {
+        if !path.starts_with(self.project_root) {
           return None;
         }
 
diff --git a/packages/transformers/js/core/src/hoist.rs b/packages/transformers/js/core/src/hoist.rs
@@ -410,7 +410,7 @@ impl<'a> Fold for Hoist<'a> {
                       if let Expr::Member(member) = &**init {
                         // Match var x = require('foo').bar;
                         if let Some(source) =
-                          match_require(&*member.obj, &self.collect.decls, self.collect.ignore_mark)
+                          match_require(&member.obj, &self.collect.decls, self.collect.ignore_mark)
                         {
                           if !self.collect.non_static_requires.contains(&source) {
                             // If this is not the first declarator in the variable declaration, we need to
@@ -742,7 +742,7 @@ impl<'a> Fold for Hoist<'a> {
       .enumerate()
       .map(|(i, expr)| {
         if i != len - 1
-          && match_require(&*expr, &self.collect.decls, self.collect.ignore_mark).is_some()
+          && match_require(&expr, &self.collect.decls, self.collect.ignore_mark).is_some()
         {
           return Box::new(Expr::Unary(UnaryExpr {
             op: UnaryOp::Bang,
@@ -1346,7 +1346,7 @@ impl Visit for Collect {
           }
           Stmt::Expr(expr) => {
             // Top-level require(). Do not traverse further so it is not marked as wrapped.
-            if let Some(_source) = self.match_require(&*expr.expr) {
+            if let Some(_source) = self.match_require(&expr.expr) {
               return;
             }
 
@@ -1844,7 +1844,7 @@ impl Visit for Collect {
 
       match &**init {
         Expr::Member(member) => {
-          if let Some(source) = self.match_require(&*member.obj) {
+          if let Some(source) = self.match_require(&member.obj) {
             // Convert member expression on require to a destructuring assignment.
             // const yx = require('y').x; -> const {x: yx} = require('x');
             let key = match &member.prop {
@@ -1875,7 +1875,7 @@ impl Visit for Collect {
         Expr::Await(await_exp) => {
           // let x = await import('foo');
           // let {x} = await import('foo');
-          if let Some(source) = match_import(&*await_exp.arg, self.ignore_mark) {
+          if let Some(source) = match_import(&await_exp.arg, self.ignore_mark) {
             self.add_pat_imports(&node.name, &source, ImportKind::DynamicImport);
             return;
           }
@@ -1903,7 +1903,7 @@ impl Visit for Collect {
         }
         Expr::Member(member) => {
           // import('foo').then(foo => ...);
-          if let Some(source) = match_import(&*member.obj, self.ignore_mark) {
+          if let Some(source) = match_import(&member.obj, self.ignore_mark) {
             if match_property_name(member).map_or(false, |f| &*f.0 == "then") {
               if let Some(ExprOrSpread { expr, .. }) = node.args.get(0) {
                 let param = match &**expr {
@@ -2078,15 +2078,15 @@ impl Collect {
         for prop in &object.props {
           match prop {
             ObjectPatProp::KeyValue(kv) => {
-              self.get_non_const_binding_idents(&*kv.value, idents);
+              self.get_non_const_binding_idents(&kv.value, idents);
             }
             ObjectPatProp::Assign(assign) => {
               if self.non_const_bindings.contains_key(&id!(assign.key)) {
                 idents.push(assign.key.clone());
               }
             }
             ObjectPatProp::Rest(rest) => {
-              self.get_non_const_binding_idents(&*rest.arg, idents);
+              self.get_non_const_binding_idents(&rest.arg, idents);
             }
           }
         }
@@ -2121,7 +2121,7 @@ fn has_binding_identifier(node: &Pat, sym: &JsWord, decls: &HashSet<Id>) -> bool
       for prop in &object.props {
         match prop {
           ObjectPatProp::KeyValue(kv) => {
-            if has_binding_identifier(&*kv.value, sym, decls) {
+            if has_binding_identifier(&kv.value, sym, decls) {
               return true;
             }
           }
@@ -2131,7 +2131,7 @@ fn has_binding_identifier(node: &Pat, sym: &JsWord, decls: &HashSet<Id>) -> bool
             }
           }
           ObjectPatProp::Rest(rest) => {
-            if has_binding_identifier(&*rest.arg, sym, decls) {
+            if has_binding_identifier(&rest.arg, sym, decls) {
               return true;
             }
           }
diff --git a/packages/transformers/js/core/src/lib.rs b/packages/transformers/js/core/src/lib.rs
@@ -484,11 +484,11 @@ pub fn transform(config: Config) -> Result<TransformResult, std::io::Error> {
                 result.diagnostics = Some(diagnostics);
               }
 
-              let (buf, mut src_map_buf) =
+              let (buf, src_map_buf) =
                 emit(source_map.clone(), comments, &module, config.source_maps)?;
               if config.source_maps
                 && source_map
-                  .build_source_map(&mut src_map_buf)
+                  .build_source_map(&src_map_buf)
                   .to_writer(&mut map_buf)
                   .is_ok()
               {
diff --git a/packages/transformers/js/core/src/utils.rs b/packages/transformers/js/core/src/utils.rs
@@ -93,7 +93,7 @@ pub fn match_str(node: &ast::Expr) -> Option<(JsWord, Span)> {
 
 pub fn match_property_name(node: &ast::MemberExpr) -> Option<(JsWord, Span)> {
   match &node.prop {
-    ast::MemberProp::Computed(s) => match_str(&*s.expr),
+    ast::MemberProp::Computed(s) => match_str(&s.expr),
     ast::MemberProp::Ident(id) => Some((id.sym.clone(), id.span)),
     ast::MemberProp::PrivateName(_) => None,
   }
@@ -126,7 +126,7 @@ pub fn match_require(node: &ast::Expr, decls: &HashSet<Id>, ignore_mark: Mark) -
             && !is_marked(ident.span, ignore_mark)
           {
             if let Some(arg) = call.args.get(0) {
-              return match_str(&*arg.expr).map(|(name, _)| name);
+              return match_str(&arg.expr).map(|(name, _)| name);
             }
           }
 
@@ -135,7 +135,7 @@ pub fn match_require(node: &ast::Expr, decls: &HashSet<Id>, ignore_mark: Mark) -
         Expr::Member(member) => {
           if match_member_expr(member, vec!["module", "require"], decls) {
             if let Some(arg) = call.args.get(0) {
-              return match_str(&*arg.expr).map(|(name, _)| name);
+              return match_str(&arg.expr).map(|(name, _)| name);
             }
           }
 
@@ -156,7 +156,7 @@ pub fn match_import(node: &ast::Expr, ignore_mark: Mark) -> Option<JsWord> {
     Expr::Call(call) => match &call.callee {
       Callee::Import(ident) if !is_marked(ident.span, ignore_mark) => {
         if let Some(arg) = call.args.get(0) {
-          return match_str(&*arg.expr).map(|(name, _)| name);
+          return match_str(&arg.expr).map(|(name, _)| name);
         }
         None
       }

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+/* @jsx h */`
	`2`	`+`
`1`	`3`	`const Boom = () => {`
`2`	`4`	`const littleBoom = ['hello', 'world']`
`3`	`5`	`return <div>{...littleBoom.map(el => el)}</div>`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ impl<'a> Fold for InlineFS<'a> {`
`53`	`53`	`if let Some((source, specifier)) = self.match_module_reference(expr) {`
`54`	`54`	`if &source == "fs" && &specifier == "readFileSync" {`
`55`	`55`	`if let Some(arg) = call.args.get(0) {`
`56`		`- if let Some(res) = self.evaluate_fs_arg(&*arg.expr, call.args.get(1), call.span) {`
	`56`	`+ if let Some(res) = self.evaluate_fs_arg(&arg.expr, call.args.get(1), call.span) {`
`57`	`57`	`return res;`
`58`	`58`	`}`
`59`	`59`	`}`
`@@ -90,7 +90,7 @@ impl<'a> InlineFS<'a> {`
`90`	`90`	`_ => return None,`
`91`	`91`	`};`
`92`	`92`
`93`		`- if let Some(source) = self.collect.match_require(&*member.obj) {`
	`93`	`+ if let Some(source) = self.collect.match_require(&member.obj) {`
`94`	`94`	`return Some((source, prop));`
`95`	`95`	`}`
`96`	`96`
`@@ -127,7 +127,7 @@ impl<'a> InlineFS<'a> {`
`127`	`127`	`Ok(path) => path,`
`128`	`128`	`Err(_err) => return None,`
`129`	`129`	`};`
`130`		`- if !path.starts_with(&self.project_root) {`
	`130`	`+ if !path.starts_with(self.project_root) {`
`131`	`131`	`return None;`
`132`	`132`	`}`
`133`	`133`
Original file line number	Diff line number	Diff line change
`@@ -410,7 +410,7 @@ impl<'a> Fold for Hoist<'a> {`
`410`	`410`	`if let Expr::Member(member) = &**init {`
`411`	`411`	`// Match var x = require('foo').bar;`
`412`	`412`	`if let Some(source) =`
`413`		`- match_require(&*member.obj, &self.collect.decls, self.collect.ignore_mark)`
	`413`	`+ match_require(&member.obj, &self.collect.decls, self.collect.ignore_mark)`
`414`	`414`	`{`
`415`	`415`	`if !self.collect.non_static_requires.contains(&source) {`
`416`	`416`	`// If this is not the first declarator in the variable declaration, we need to`
`@@ -742,7 +742,7 @@ impl<'a> Fold for Hoist<'a> {`
`742`	`742`	`.enumerate()`
`743`	`743`	`.map(\|(i, expr)\| {`
`744`	`744`	`if i != len - 1`
`745`		`- && match_require(&*expr, &self.collect.decls, self.collect.ignore_mark).is_some()`
	`745`	`+ && match_require(&expr, &self.collect.decls, self.collect.ignore_mark).is_some()`
`746`	`746`	`{`
`747`	`747`	`return Box::new(Expr::Unary(UnaryExpr {`
`748`	`748`	`op: UnaryOp::Bang,`
`@@ -1346,7 +1346,7 @@ impl Visit for Collect {`
`1346`	`1346`	`}`
`1347`	`1347`	`Stmt::Expr(expr) => {`
`1348`	`1348`	`// Top-level require(). Do not traverse further so it is not marked as wrapped.`
`1349`		`- if let Some(_source) = self.match_require(&*expr.expr) {`
	`1349`	`+ if let Some(_source) = self.match_require(&expr.expr) {`
`1350`	`1350`	`return;`
`1351`	`1351`	`}`
`1352`	`1352`
`@@ -1844,7 +1844,7 @@ impl Visit for Collect {`
`1844`	`1844`
`1845`	`1845`	`match &**init {`
`1846`	`1846`	`Expr::Member(member) => {`
`1847`		`- if let Some(source) = self.match_require(&*member.obj) {`
	`1847`	`+ if let Some(source) = self.match_require(&member.obj) {`
`1848`	`1848`	`// Convert member expression on require to a destructuring assignment.`
`1849`	`1849`	`// const yx = require('y').x; -> const {x: yx} = require('x');`
`1850`	`1850`	`let key = match &member.prop {`
`@@ -1875,7 +1875,7 @@ impl Visit for Collect {`
`1875`	`1875`	`Expr::Await(await_exp) => {`
`1876`	`1876`	`// let x = await import('foo');`
`1877`	`1877`	`// let {x} = await import('foo');`
`1878`		`- if let Some(source) = match_import(&*await_exp.arg, self.ignore_mark) {`
	`1878`	`+ if let Some(source) = match_import(&await_exp.arg, self.ignore_mark) {`
`1879`	`1879`	`self.add_pat_imports(&node.name, &source, ImportKind::DynamicImport);`
`1880`	`1880`	`return;`
`1881`	`1881`	`}`
`@@ -1903,7 +1903,7 @@ impl Visit for Collect {`
`1903`	`1903`	`}`
`1904`	`1904`	`Expr::Member(member) => {`
`1905`	`1905`	`// import('foo').then(foo => ...);`
`1906`		`- if let Some(source) = match_import(&*member.obj, self.ignore_mark) {`
	`1906`	`+ if let Some(source) = match_import(&member.obj, self.ignore_mark) {`
`1907`	`1907`	`if match_property_name(member).map_or(false, \|f\| &*f.0 == "then") {`
`1908`	`1908`	`if let Some(ExprOrSpread { expr, .. }) = node.args.get(0) {`
`1909`	`1909`	`let param = match &**expr {`
`@@ -2078,15 +2078,15 @@ impl Collect {`
`2078`	`2078`	`for prop in &object.props {`
`2079`	`2079`	`match prop {`
`2080`	`2080`	`ObjectPatProp::KeyValue(kv) => {`
`2081`		`- self.get_non_const_binding_idents(&*kv.value, idents);`
	`2081`	`+ self.get_non_const_binding_idents(&kv.value, idents);`
`2082`	`2082`	`}`
`2083`	`2083`	`ObjectPatProp::Assign(assign) => {`
`2084`	`2084`	`if self.non_const_bindings.contains_key(&id!(assign.key)) {`
`2085`	`2085`	`idents.push(assign.key.clone());`
`2086`	`2086`	`}`
`2087`	`2087`	`}`
`2088`	`2088`	`ObjectPatProp::Rest(rest) => {`
`2089`		`- self.get_non_const_binding_idents(&*rest.arg, idents);`
	`2089`	`+ self.get_non_const_binding_idents(&rest.arg, idents);`
`2090`	`2090`	`}`
`2091`	`2091`	`}`
`2092`	`2092`	`}`
`@@ -2121,7 +2121,7 @@ fn has_binding_identifier(node: &Pat, sym: &JsWord, decls: &HashSet<Id>) -> bool`
`2121`	`2121`	`for prop in &object.props {`
`2122`	`2122`	`match prop {`
`2123`	`2123`	`ObjectPatProp::KeyValue(kv) => {`
`2124`		`- if has_binding_identifier(&*kv.value, sym, decls) {`
	`2124`	`+ if has_binding_identifier(&kv.value, sym, decls) {`
`2125`	`2125`	`return true;`
`2126`	`2126`	`}`
`2127`	`2127`	`}`
`@@ -2131,7 +2131,7 @@ fn has_binding_identifier(node: &Pat, sym: &JsWord, decls: &HashSet<Id>) -> bool`
`2131`	`2131`	`}`
`2132`	`2132`	`}`
`2133`	`2133`	`ObjectPatProp::Rest(rest) => {`
`2134`		`- if has_binding_identifier(&*rest.arg, sym, decls) {`
	`2134`	`+ if has_binding_identifier(&rest.arg, sym, decls) {`
`2135`	`2135`	`return true;`
`2136`	`2136`	`}`
`2137`	`2137`	`}`
Original file line number	Diff line number	Diff line change
`@@ -484,11 +484,11 @@ pub fn transform(config: Config) -> Result<TransformResult, std::io::Error> {`
`484`	`484`	`result.diagnostics = Some(diagnostics);`
`485`	`485`	`}`
`486`	`486`
`487`		`- let (buf, mut src_map_buf) =`
	`487`	`+ let (buf, src_map_buf) =`
`488`	`488`	`emit(source_map.clone(), comments, &module, config.source_maps)?;`
`489`	`489`	`if config.source_maps`
`490`	`490`	`&& source_map`
`491`		`- .build_source_map(&mut src_map_buf)`
	`491`	`+ .build_source_map(&src_map_buf)`
`492`	`492`	`.to_writer(&mut map_buf)`
`493`	`493`	`.is_ok()`
`494`	`494`	`{`
Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,7 @@ pub fn match_str(node: &ast::Expr) -> Option<(JsWord, Span)> {`
`93`	`93`
`94`	`94`	`pub fn match_property_name(node: &ast::MemberExpr) -> Option<(JsWord, Span)> {`
`95`	`95`	`match &node.prop {`
`96`		`- ast::MemberProp::Computed(s) => match_str(&*s.expr),`
	`96`	`+ ast::MemberProp::Computed(s) => match_str(&s.expr),`
`97`	`97`	`ast::MemberProp::Ident(id) => Some((id.sym.clone(), id.span)),`
`98`	`98`	`ast::MemberProp::PrivateName(_) => None,`
`99`	`99`	`}`
`@@ -126,7 +126,7 @@ pub fn match_require(node: &ast::Expr, decls: &HashSet<Id>, ignore_mark: Mark) -`
`126`	`126`	`&& !is_marked(ident.span, ignore_mark)`
`127`	`127`	`{`
`128`	`128`	`if let Some(arg) = call.args.get(0) {`
`129`		`- return match_str(&*arg.expr).map(\|(name, _)\| name);`
	`129`	`+ return match_str(&arg.expr).map(\|(name, _)\| name);`
`130`	`130`	`}`
`131`	`131`	`}`
`132`	`132`
`@@ -135,7 +135,7 @@ pub fn match_require(node: &ast::Expr, decls: &HashSet<Id>, ignore_mark: Mark) -`
`135`	`135`	`Expr::Member(member) => {`
`136`	`136`	`if match_member_expr(member, vec!["module", "require"], decls) {`
`137`	`137`	`if let Some(arg) = call.args.get(0) {`
`138`		`- return match_str(&*arg.expr).map(\|(name, _)\| name);`
	`138`	`+ return match_str(&arg.expr).map(\|(name, _)\| name);`
`139`	`139`	`}`
`140`	`140`	`}`
`141`	`141`
`@@ -156,7 +156,7 @@ pub fn match_import(node: &ast::Expr, ignore_mark: Mark) -> Option<JsWord> {`
`156`	`156`	`Expr::Call(call) => match &call.callee {`
`157`	`157`	`Callee::Import(ident) if !is_marked(ident.span, ignore_mark) => {`
`158`	`158`	`if let Some(arg) = call.args.get(0) {`
`159`		`- return match_str(&*arg.expr).map(\|(name, _)\| name);`
	`159`	`+ return match_str(&arg.expr).map(\|(name, _)\| name);`
`160`	`160`	`}`
`161`	`161`	`None`
`162`	`162`	`}`