Merge #1482

1482: Some clippy fixes for 1.36 r=kjeremy a=kjeremy

Some clippy fixes now that 1.36 is released. ~~Plus the requisite format run (I can rebase after #1481 is merged to make this cleaner) .~~

The change from `map(|it| *it)` to `copied()` changes the minimum rust stable to 1.36.


Co-authored-by: Jeremy Kolb <kjeremy@gmail.com>

Author: bors[bot]

crates/gen_lsp_server/src/lib.rs

@@ -130,7 +130,7 @@ fn initialize(
         Ok(RawMessage::Notification(n)) => {
             n.cast::<Initialized>().map_err(|_| "expected initialized notification")?;
         }
-        _ => Err(format!("expected initialized notification"))?,
+        _ => Err("expected initialized notification".to_string())?,
     }
     Ok(params)
 }

crates/ra_assists/src/auto_import.rs

@@ -39,13 +39,13 @@ fn collect_path_segments_raw<'a>(
     // We need to reverse only the new added segments
     let only_new_segments = segments.split_at_mut(oldlen).1;
     only_new_segments.reverse();
-    return Some(segments.len() - oldlen);
+    Some(segments.len() - oldlen)
 }
 
 fn fmt_segments(segments: &[SmolStr]) -> String {
     let mut buf = String::new();
     fmt_segments_raw(segments, &mut buf);
-    return buf;
+    buf
 }
 
 fn fmt_segments_raw(segments: &[SmolStr], buf: &mut String) {
@@ -61,7 +61,7 @@ fn fmt_segments_raw(segments: &[SmolStr], buf: &mut String) {
 
 // Returns the numeber of common segments.
 fn compare_path_segments(left: &[SmolStr], right: &[&ast::PathSegment]) -> usize {
-    return left.iter().zip(right).filter(|(l, r)| compare_path_segment(l, r)).count();
+    left.iter().zip(right).filter(|(l, r)| compare_path_segment(l, r)).count()
 }
 
 fn compare_path_segment(a: &SmolStr, b: &ast::PathSegment) -> bool {
@@ -320,7 +320,7 @@ fn walk_use_tree_for_best_action<'a>(
 
     // We remove the segments added
     current_path_segments.truncate(prev_len);
-    return action;
+    action
 }
 
 fn best_action_for_target<'b, 'a: 'b>(
@@ -339,7 +339,7 @@ fn best_action_for_target<'b, 'a: 'b>(
         });
 
     match best_action {
-        Some(action) => return action,
+        Some(action) => action,
         None => {
             // We have no action and no UseItem was found in container so we find
             // another item and we use it as anchor.
@@ -350,7 +350,7 @@ fn best_action_for_target<'b, 'a: 'b>(
                 .find(|n| n.range().start() < anchor.range().start())
                 .or_else(|| Some(anchor));
 
-            return ImportAction::add_new_use(anchor, false);
+            ImportAction::add_new_use(anchor, false)
         }
     }
 }

crates/ra_cli/src/main.rs

@@ -112,6 +112,6 @@ fn read_stdin() -> Result<String> {
 }
 
 fn rsplit_at_char(s: &str, c: char) -> Result<(&str, &str)> {
-    let idx = s.rfind(":").ok_or_else(|| format!("no `{}` in {}", c, s))?;
+    let idx = s.rfind(':').ok_or_else(|| format!("no `{}` in {}", c, s))?;
     Ok((&s[..idx], &s[idx + 1..]))
 }

crates/ra_db/src/input.rs

@@ -139,7 +139,7 @@ impl CrateGraph {
     }
 
     pub fn iter<'a>(&'a self) -> impl Iterator<Item = CrateId> + 'a {
-        self.arena.keys().map(|it| *it)
+        self.arena.keys().copied()
     }
 
     pub fn crate_root(&self, crate_id: CrateId) -> FileId {
@@ -191,7 +191,7 @@ impl CrateGraph {
                 return true;
             }
         }
-        return false;
+        false
     }
 }
 

crates/ra_hir/src/code_model/docs.rs

@@ -74,7 +74,7 @@ pub(crate) fn documentation_query(
         DocDef::Module(it) => docs_from_ast(&*it.declaration_source(db)?.ast),
         DocDef::StructField(it) => match it.source(db).ast {
             FieldSource::Named(named) => docs_from_ast(&*named),
-            FieldSource::Pos(..) => return None,
+            FieldSource::Pos(..) => None,
         },
         DocDef::Struct(it) => docs_from_ast(&*it.source(db).ast),
         DocDef::Enum(it) => docs_from_ast(&*it.source(db).ast),

crates/ra_hir/src/expr.rs

@@ -150,7 +150,7 @@ impl BodySourceMap {
     }
 
     pub(crate) fn field_syntax(&self, expr: ExprId, field: usize) -> AstPtr<ast::NamedField> {
-        self.field_map[&(expr, field)].clone()
+        self.field_map[&(expr, field)]
     }
 }
 
@@ -471,15 +471,15 @@ impl Pat {
         match self {
             Pat::Range { .. } | Pat::Lit(..) | Pat::Path(..) | Pat::Wild | Pat::Missing => {}
             Pat::Bind { subpat, .. } => {
-                subpat.iter().map(|pat| *pat).for_each(f);
+                subpat.iter().copied().for_each(f);
             }
             Pat::Tuple(args) | Pat::TupleStruct { args, .. } => {
-                args.iter().map(|pat| *pat).for_each(f);
+                args.iter().copied().for_each(f);
             }
             Pat::Ref { pat, .. } => f(*pat),
             Pat::Slice { prefix, rest, suffix } => {
                 let total_iter = prefix.iter().chain(rest.iter()).chain(suffix.iter());
-                total_iter.map(|pat| *pat).for_each(f);
+                total_iter.copied().for_each(f);
             }
             Pat::Struct { args, .. } => {
                 args.iter().map(|f| f.pat).for_each(f);

crates/ra_hir/src/expr/scope.rs

@@ -72,7 +72,7 @@ impl ExprScopes {
     }
 
     pub(crate) fn scope_for(&self, expr: ExprId) -> Option<ScopeId> {
-        self.scope_by_expr.get(&expr).map(|&scope| scope)
+        self.scope_by_expr.get(&expr).copied()
     }
 
     pub(crate) fn scope_by_expr(&self) -> &FxHashMap<ExprId, ScopeId> {

crates/ra_hir/src/lang_item.rs

@@ -122,7 +122,7 @@ impl LangItems {
         module: Module,
     ) {
         if let Some(module_lang_items) = db.module_lang_items(module) {
-            self.items.extend(module_lang_items.items.iter().map(|(k, v)| (k.clone(), v.clone())))
+            self.items.extend(module_lang_items.items.iter().map(|(k, v)| (k.clone(), *v)))
         }
 
         // Look for lang items in the children
@@ -142,7 +142,7 @@ impl LangItems {
     {
         let node = item.source(db).ast;
         if let Some(lang_item_name) = lang_item_name(&*node) {
-            self.items.entry(lang_item_name).or_insert(constructor(item));
+            self.items.entry(lang_item_name).or_insert_with(|| constructor(item));
         }
     }
 }

crates/ra_hir/src/mock.rs

@@ -76,7 +76,7 @@ impl MockDatabase {
 
     pub fn diagnostics(&self) -> String {
         let mut buf = String::from("\n");
-        let mut files: Vec<FileId> = self.files.values().map(|&it| it).collect();
+        let mut files: Vec<FileId> = self.files.values().copied().collect();
         files.sort();
         for file in files {
             let module = crate::source_binder::module_from_file_id(self, file).unwrap();

crates/ra_hir/src/nameres/collector.rs

@@ -227,10 +227,8 @@ where
                             .items
                             .iter()
                             .map(|(name, res)| (name.clone(), Either::A(res.clone())));
-                        let macros = scope
-                            .macros
-                            .iter()
-                            .map(|(name, res)| (name.clone(), Either::B(res.clone())));
+                        let macros =
+                            scope.macros.iter().map(|(name, res)| (name.clone(), Either::B(*res)));
 
                         let all = items.chain(macros).collect::<Vec<_>>();
                         self.update(module_id, Some(import_id), &all);
@@ -243,10 +241,8 @@ where
                             .items
                             .iter()
                             .map(|(name, res)| (name.clone(), Either::A(res.clone())));
-                        let macros = scope
-                            .macros
-                            .iter()
-                            .map(|(name, res)| (name.clone(), Either::B(res.clone())));
+                        let macros =
+                            scope.macros.iter().map(|(name, res)| (name.clone(), Either::B(*res)));
 
                         let all = items.chain(macros).collect::<Vec<_>>();
 
@@ -651,7 +647,7 @@ fn resolve_submodule(
         candidates.push(file_dir_mod.clone());
     };
     let sr = db.source_root(source_root_id);
-    let mut points_to = candidates.into_iter().filter_map(|path| sr.files.get(&path)).map(|&it| it);
+    let mut points_to = candidates.into_iter().filter_map(|path| sr.files.get(&path)).copied();
     // FIXME: handle ambiguity
     match points_to.next() {
         Some(file_id) => Ok(file_id),