Apply suggestions from rust-clippy (parcel-bundler#6256)

packages/transformers/js/core/src/decl_collector.rs

@@ -14,7 +14,7 @@ pub fn collect_decls(module: &ast::Module) -> HashSet<(JsWord, SyntaxContext)> {
     in_var: false,
   };
   module.visit_with(&ast::Invalid { span: DUMMY_SP } as _, &mut c);
-  return c.decls;
+  c.decls
 }
 
 struct DeclCollector {

packages/transformers/js/core/src/dependency_collector.rs

@@ -274,7 +274,7 @@ impl<'a> Fold for DependencyCollector<'a> {
       self.config.source_type,
     );
 
-    return node;
+    node
   }
 
   fn fold_named_export(&mut self, node: ast::NamedExport) -> ast::NamedExport {
@@ -293,7 +293,7 @@ impl<'a> Fold for DependencyCollector<'a> {
       );
     }
 
-    return node;
+    node
   }
 
   fn fold_export_all(&mut self, node: ast::ExportAll) -> ast::ExportAll {
@@ -306,7 +306,7 @@ impl<'a> Fold for DependencyCollector<'a> {
       self.config.source_type,
     );
 
-    return node;
+    node
   }
 
   fn fold_try_stmt(&mut self, node: ast::TryStmt) -> ast::TryStmt {
@@ -315,15 +315,8 @@ impl<'a> Fold for DependencyCollector<'a> {
     let block = node.block.fold_with(self);
     self.in_try = false;
 
-    let handler = match node.handler {
-      Some(handler) => Some(handler.fold_with(self)),
-      None => None,
-    };
-
-    let finalizer = match node.finalizer {
-      Some(finalizer) => Some(finalizer.fold_with(self)),
-      None => None,
-    };
+    let handler = node.handler.map(|handler| handler.fold_with(self));
+    let finalizer = node.finalizer.map(|finalizer| finalizer.fold_with(self));
 
     ast::TryStmt {
       span: node.span,
@@ -411,23 +404,23 @@ impl<'a> Fold for DependencyCollector<'a> {
             return node.fold_children_with(self);
           }
           "__parcel__require__" => {
-            let mut call = node.clone().fold_children_with(self);
+            let mut call = node.fold_children_with(self);
             call.callee = ast::ExprOrSuper::Expr(Box::new(ast::Expr::Ident(ast::Ident::new(
               "require".into(),
               DUMMY_SP.apply_mark(self.ignore_mark),
             ))));
             return call;
           }
           "__parcel__import__" => {
-            let mut call = node.clone().fold_children_with(self);
+            let mut call = node.fold_children_with(self);
             call.callee = ast::ExprOrSuper::Expr(Box::new(ast::Expr::Ident(ast::Ident::new(
               "import".into(),
               DUMMY_SP.apply_mark(self.ignore_mark),
             ))));
             return call;
           }
           "__parcel__importScripts__" => {
-            let mut call = node.clone().fold_children_with(self);
+            let mut call = node.fold_children_with(self);
             call.callee = ast::ExprOrSuper::Expr(Box::new(ast::Expr::Ident(ast::Ident::new(
               "importScripts".into(),
               DUMMY_SP.apply_mark(self.ignore_mark),
@@ -457,7 +450,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 let Some(_) = match_require(&*expr.expr, self.decls, Mark::fresh(Mark::root())) {
+              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;
@@ -488,7 +481,7 @@ impl<'a> Fold for DependencyCollector<'a> {
                               //   => Promise.resolve().then(() => require('foo')).then(res => __importStar(res))
                               if let Some(require_node) = self.require_node.clone() {
                                 self.require_node = None;
-                                return build_promise_chain(node.clone(), require_node);
+                                return build_promise_chain(node, require_node);
                               }
                             }
                             _ => {}
@@ -591,8 +584,7 @@ impl<'a> Fold for DependencyCollector<'a> {
           return node;
         };
 
-        node.args[0].expr =
-          Box::new(self.add_url_dependency(specifier.clone(), span, kind.clone(), source_type));
+        node.args[0].expr = Box::new(self.add_url_dependency(specifier, span, kind, source_type));
 
         match opts {
           Some(opts) => {
@@ -642,7 +634,7 @@ impl<'a> Fold for DependencyCollector<'a> {
 
     // Replace import() with require()
     if kind == DependencyKind::DynamicImport {
-      let mut call = node.clone();
+      let mut call = node;
       if !self.config.scope_hoist {
         let name = match &self.config.source_type {
           SourceType::Module => "require",
@@ -766,12 +758,8 @@ impl<'a> Fold for DependencyCollector<'a> {
         };
 
         let (source_type, opts) = match_worker_type(args.get(1));
-        let placeholder = self.add_url_dependency(
-          specifier.clone(),
-          span,
-          DependencyKind::WebWorker,
-          source_type,
-        );
+        let placeholder =
+          self.add_url_dependency(specifier, span, DependencyKind::WebWorker, source_type);
 
         // Replace argument with a require call to resolve the URL at runtime.
         let mut node = node.clone();
@@ -797,7 +785,7 @@ impl<'a> Fold for DependencyCollector<'a> {
       }
     }
 
-    return node.fold_children_with(self);
+    node.fold_children_with(self)
   }
 
   fn fold_member_expr(&mut self, mut node: ast::MemberExpr) -> ast::MemberExpr {
@@ -824,7 +812,7 @@ impl<'a> Fold for DependencyCollector<'a> {
 
     if let Some((specifier, span)) = self.match_new_url(&node, self.decls) {
       let url = self.add_url_dependency(
-        specifier.clone(),
+        specifier,
         span,
         DependencyKind::URL,
         self.config.source_type,
@@ -887,11 +875,7 @@ impl<'a> DependencyCollector<'a> {
       if let Some(arg) = args.get(0) {
         let (resolve, expr) = match &*arg.expr {
           Fn(f) => {
-            let param = if let Some(param) = f.function.params.get(0) {
-              Some(&param.pat)
-            } else {
-              None
-            };
+            let param = f.function.params.get(0).map(|param| &param.pat);
             let body = if let Some(body) = &f.function.body {
               self.match_block_stmt_expr(body)
             } else {
@@ -921,9 +905,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 let Some(_) =
-                      match_require(&*arg.expr, self.decls, Mark::fresh(Mark::root()))
-                    {
+                    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);
@@ -1048,7 +1030,7 @@ fn build_promise_chain(node: ast::CallExpr, require_node: ast::CallExpr) -> ast:
     }
   }
 
-  return node;
+  node
 }
 
 fn create_url_constructor(url: ast::Expr, use_import_meta: bool) -> ast::Expr {
@@ -1113,7 +1095,7 @@ impl Fold for PromiseTransformer {
       }
     }
 
-    return swc_ecmascript::visit::fold_return_stmt(self, node);
+    swc_ecmascript::visit::fold_return_stmt(self, node)
   }
 
   fn fold_arrow_expr(&mut self, node: ast::ArrowExpr) -> ast::ArrowExpr {
@@ -1127,7 +1109,7 @@ impl Fold for PromiseTransformer {
       }
     }
 
-    return swc_ecmascript::visit::fold_arrow_expr(self, node);
+    swc_ecmascript::visit::fold_arrow_expr(self, node)
   }
 
   fn fold_expr(&mut self, node: ast::Expr) -> ast::Expr {
@@ -1143,7 +1125,7 @@ impl Fold for PromiseTransformer {
       }
     }
 
-    return node;
+    node
   }
 }
 
@@ -1434,10 +1416,5 @@ fn match_worker_type(expr: Option<&ast::ExprOrSpread>) -> (SourceType, Option<as
     }
   }
 
-  let expr = match expr {
-    None => None,
-    Some(e) => Some(e.clone()),
-  };
-
-  (SourceType::Script, expr)
+  (SourceType::Script, expr.cloned())
 }

packages/transformers/js/core/src/env_replacer.rs

@@ -242,11 +242,7 @@ impl<'a> EnvReplacer<'a> {
                 span: DUMMY_SP,
                 name: *kv.value.clone().fold_with(self),
                 init: if let Some(key) = key {
-                  if let Some(init) = self.replace(&key, false) {
-                    Some(Box::new(init))
-                  } else {
-                    None
-                  }
+                  self.replace(&key, false).map(Box::new)
                 } else {
                   None
                 },

packages/transformers/js/core/src/fs.rs

@@ -100,7 +100,7 @@ impl<'a> InlineFS<'a> {
         match &member.obj {
           ExprOrSuper::Expr(expr) => {
             if let Some(source) = self.collect.match_require(expr) {
-              return Some((source.clone(), prop));
+              return Some((source, prop));
             }
 
             match &**expr {
@@ -123,7 +123,7 @@ impl<'a> InlineFS<'a> {
       _ => {}
     }
 
-    return None;
+    None
   }
 
   fn evaluate_fs_arg(
@@ -234,7 +234,7 @@ impl<'a> InlineFS<'a> {
           Some(contents)
         }
       }
-      _ => return None,
+      _ => None,
     }
   }
 }
@@ -332,7 +332,7 @@ impl<'a> Fold for Evaluator<'a> {
           }
         }
 
-        return node;
+        node
       }
       _ => node,
     }

packages/transformers/js/core/src/global_replacer.rs

@@ -193,7 +193,7 @@ impl<'a> Fold for GlobalReplacer<'a> {
       _ => {}
     }
 
-    return node;
+    node
   }
 
   fn fold_module(&mut self, node: ast::Module) -> ast::Module {
@@ -206,7 +206,7 @@ impl<'a> Fold for GlobalReplacer<'a> {
         .values()
         .map(|stmt| ast::ModuleItem::Stmt(stmt.clone())),
     );
-    return node;
+    node
   }
 }
 

packages/transformers/js/core/src/hoist.rs

@@ -744,7 +744,7 @@ impl<'a> Fold for Hoist<'a> {
       .enumerate()
       .map(|(i, expr)| {
         if i != len - 1 {
-          if let Some(_) = match_require(&*expr, &self.collect.decls, self.collect.ignore_mark) {
+          if match_require(&*expr, &self.collect.decls, self.collect.ignore_mark).is_some() {
             return Box::new(Expr::Unary(UnaryExpr {
               op: UnaryOp::Bang,
               arg: expr.fold_with(self),
@@ -919,7 +919,7 @@ impl<'a> Fold for Hoist<'a> {
             } else {
               PatOrExpr::Pat(Box::new(Pat::Expr(Box::new(Expr::Member(MemberExpr {
                 span: member.span,
-                obj: ExprOrSuper::Expr(Box::new(Expr::Ident(ident.id.clone()))),
+                obj: ExprOrSuper::Expr(Box::new(Expr::Ident(ident.id))),
                 prop: member.prop.clone().fold_with(self),
                 computed: member.computed,
               })))))
@@ -1022,7 +1022,7 @@ impl<'a> Hoist<'a> {
     self
       .imported_symbols
       .insert(new_name.clone(), (source.clone(), local.clone(), loc));
-    return Ident::new(new_name, span);
+    Ident::new(new_name, span)
   }
 
   fn get_require_ident(&self, local: &JsWord) -> Ident {
@@ -1046,7 +1046,7 @@ impl<'a> Hoist<'a> {
 
     let mut span = span;
     span.ctxt = SyntaxContext::empty();
-    return Ident::new(new_name, span);
+    Ident::new(new_name, span)
   }
 
   fn handle_non_const_require(&mut self, v: &VarDeclarator, source: &JsWord) {
@@ -1647,10 +1647,7 @@ impl Visit for Collect {
                   match node.args.get(0) {
                     Some(ExprOrSpread { expr, .. }) => {
                       let param = match &**expr {
-                        Expr::Fn(func) => match func.function.params.get(0) {
-                          Some(param) => Some(&param.pat),
-                          None => None,
-                        },
+                        Expr::Fn(func) => func.function.params.get(0).map(|param| &param.pat),
                         Expr::Arrow(arrow) => arrow.params.get(0),
                         _ => None,
                       };
@@ -1942,14 +1939,14 @@ mod tests {
       let mut emitter = swc_ecmascript::codegen::Emitter {
         cfg: config,
         comments: Some(&comments),
-        cm: source_map.clone(),
+        cm: source_map,
         wr: writer,
       };
 
       emitter.emit_module(&program).unwrap();
     }
 
-    return String::from_utf8(buf).unwrap();
+    String::from_utf8(buf).unwrap()
   }
 
   macro_rules! map(

packages/transformers/js/core/src/lib.rs

@@ -409,9 +409,10 @@ pub fn transform(config: Config) -> Result<TransformResult, std::io::Error> {
             let (buf, mut src_map_buf) =
               emit(source_map.clone(), comments, &program, config.source_maps)?;
             if config.source_maps {
-              if let Ok(_) = source_map
+              if source_map
                 .build_source_map(&mut src_map_buf)
                 .to_writer(&mut map_buf)
+                .is_ok()
               {
                 result.map = Some(String::from_utf8(map_buf).unwrap());
               }
@@ -496,12 +497,12 @@ fn emit(
     let mut emitter = swc_ecmascript::codegen::Emitter {
       cfg: config,
       comments: Some(&comments),
-      cm: source_map.clone(),
+      cm: source_map,
       wr: writer,
     };
 
     emitter.emit_module(&program)?;
   }
 
-  return Ok((buf, src_map_buf));
+  Ok((buf, src_map_buf))
 }

packages/transformers/js/core/src/utils.rs

@@ -46,7 +46,7 @@ pub fn match_member_expr(
     }
   }
 
-  return false;
+  false
 }
 
 pub fn create_require(specifier: swc_atoms::JsWord) -> ast::CallExpr {