Merge #1493

bors[bot] · kjeremy · bors[bot] · commit feae74e02c4e · 2019-07-05T16:07:11.000Z
1493: Clippy trivially_copy_pass_by_ref r=matklad a=kjeremy

Clippy says that this is more efficient.

Co-authored-by: Jeremy Kolb &lt;kjeremy@gmail.com&gt;
diff --git a/crates/ra_hir/src/adt.rs b/crates/ra_hir/src/adt.rs
@@ -34,8 +34,8 @@ impl AdtDef {
 }
 
 impl Struct {
-    pub(crate) fn variant_data(&self, db: &impl DefDatabase) -> Arc<VariantData> {
-        db.struct_data(*self).variant_data.clone()
+    pub(crate) fn variant_data(self, db: &impl DefDatabase) -> Arc<VariantData> {
+        db.struct_data(self).variant_data.clone()
     }
 }
 
@@ -69,7 +69,7 @@ fn variants(enum_def: &ast::EnumDef) -> impl Iterator<Item = &ast::EnumVariant>
 
 impl EnumVariant {
     pub(crate) fn source_impl(
-        &self,
+        self,
         db: &(impl DefDatabase + AstDatabase),
     ) -> Source<TreeArc<ast::EnumVariant>> {
         let src = self.parent.source(db);
@@ -81,7 +81,7 @@ impl EnumVariant {
             .to_owned();
         Source { file_id: src.file_id, ast }
     }
-    pub(crate) fn variant_data(&self, db: &impl DefDatabase) -> Arc<VariantData> {
+    pub(crate) fn variant_data(self, db: &impl DefDatabase) -> Arc<VariantData> {
         db.enum_data(self.parent).variants[self.id].variant_data.clone()
     }
 }
diff --git a/crates/ra_hir/src/expr/validation.rs b/crates/ra_hir/src/expr/validation.rs
@@ -31,7 +31,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
         let body = self.func.body(db);
         for e in body.exprs() {
             if let (id, Expr::StructLit { path, fields, spread }) = e {
-                self.validate_struct_literal(id, path, fields, spread, db);
+                self.validate_struct_literal(id, path, fields, *spread, db);
             }
         }
     }
@@ -41,7 +41,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
         id: ExprId,
         _path: &Option<Path>,
         fields: &[StructLitField],
-        spread: &Option<ExprId>,
+        spread: Option<ExprId>,
         db: &impl HirDatabase,
     ) {
         if spread.is_some() {
diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs
@@ -359,8 +359,8 @@ impl AstItemDef<ast::TypeAliasDef> for TypeAliasId {
 }
 
 impl MacroCallId {
-    pub fn debug_dump(&self, db: &impl AstDatabase) -> String {
-        let loc = self.clone().loc(db);
+    pub fn debug_dump(self, db: &impl AstDatabase) -> String {
+        let loc = self.loc(db);
         let node = loc.ast_id.to_node(db);
         let syntax_str = node.syntax().text().chunks().collect::<Vec<_>>().join(" ");
 
diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
@@ -85,7 +85,7 @@ enum BindingMode {
 }
 
 impl BindingMode {
-    pub fn convert(annotation: &BindingAnnotation) -> BindingMode {
+    pub fn convert(annotation: BindingAnnotation) -> BindingMode {
         match annotation {
             BindingAnnotation::Unannotated | BindingAnnotation::Mutable => BindingMode::Move,
             BindingAnnotation::Ref => BindingMode::Ref(Mutability::Shared),
@@ -778,7 +778,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 let mode = if mode == &BindingAnnotation::Unannotated {
                     default_bm
                 } else {
-                    BindingMode::convert(mode)
+                    BindingMode::convert(*mode)
                 };
                 let inner_ty = if let Some(subpat) = subpat {
                     self.infer_pat(*subpat, expected, default_bm)
diff --git a/crates/ra_hir/src/ty/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs
@@ -58,7 +58,7 @@ impl CrateImplBlocks {
 
     pub fn lookup_impl_blocks_for_trait<'a>(
         &'a self,
-        tr: &Trait,
+        tr: Trait,
     ) -> impl Iterator<Item = ImplBlock> + 'a {
         self.impls_by_trait.get(&tr).into_iter().flat_map(|i| i.iter()).map(
             move |(module_id, impl_id)| {
@@ -68,8 +68,8 @@ impl CrateImplBlocks {
         )
     }
 
-    fn collect_recursive(&mut self, db: &impl HirDatabase, module: &Module) {
-        let module_impl_blocks = db.impls_in_module(module.clone());
+    fn collect_recursive(&mut self, db: &impl HirDatabase, module: Module) {
+        let module_impl_blocks = db.impls_in_module(module);
 
         for (impl_id, _) in module_impl_blocks.impls.iter() {
             let impl_block = ImplBlock::from_id(module_impl_blocks.module, impl_id);
@@ -94,7 +94,7 @@ impl CrateImplBlocks {
         }
 
         for child in module.children(db) {
-            self.collect_recursive(db, &child);
+            self.collect_recursive(db, child);
         }
     }
 
@@ -108,7 +108,7 @@ impl CrateImplBlocks {
             impls_by_trait: FxHashMap::default(),
         };
         if let Some(module) = krate.root_module(db) {
-            crate_impl_blocks.collect_recursive(db, &module);
+            crate_impl_blocks.collect_recursive(db, module);
         }
         Arc::new(crate_impl_blocks)
     }
diff --git a/crates/ra_hir/src/ty/primitive.rs b/crates/ra_hir/src/ty/primitive.rs
@@ -131,7 +131,7 @@ impl IntTy {
         IntTy { signedness: Signedness::Unsigned, bitness: IntBitness::X128 }
     }
 
-    pub(crate) fn ty_to_string(&self) -> &'static str {
+    pub(crate) fn ty_to_string(self) -> &'static str {
         match (self.signedness, self.bitness) {
             (Signedness::Signed, IntBitness::Xsize) => "isize",
             (Signedness::Signed, IntBitness::X8) => "i8",
diff --git a/crates/ra_hir/src/ty/traits.rs b/crates/ra_hir/src/ty/traits.rs
@@ -50,7 +50,7 @@ pub(crate) fn impls_for_trait_query(
         impls.extend(db.impls_for_trait(dep.krate, trait_).iter());
     }
     let crate_impl_blocks = db.impls_in_crate(krate);
-    impls.extend(crate_impl_blocks.lookup_impl_blocks_for_trait(&trait_));
+    impls.extend(crate_impl_blocks.lookup_impl_blocks_for_trait(trait_));
     impls.into_iter().collect::<Vec<_>>().into()
 }
 
diff --git a/crates/ra_ide_api/src/impls.rs b/crates/ra_ide_api/src/impls.rs
@@ -65,7 +65,7 @@ fn impls_for_trait(
 
     Some(
         impls
-            .lookup_impl_blocks_for_trait(&tr)
+            .lookup_impl_blocks_for_trait(tr)
             .map(|imp| NavigationTarget::from_impl_block(db, imp))
             .collect(),
     )
diff --git a/crates/ra_ide_api/src/line_index_utils.rs b/crates/ra_ide_api/src/line_index_utils.rs
@@ -213,7 +213,7 @@ impl RunningLineCol {
         self.col_adjust = TextUnit::from(0);
     }
 
-    fn adjust_col(&mut self, range: &TextRange) {
+    fn adjust_col(&mut self, range: TextRange) {
         self.col_adjust += range.len() - TextUnit::from(1);
     }
 }
@@ -244,7 +244,7 @@ pub fn translate_offset_with_edit(
                         let clamp = offset.min(x.start());
                         return res.to_line_col(clamp);
                     } else {
-                        res.adjust_col(x);
+                        res.adjust_col(*x);
                     }
                 }
             }
diff --git a/crates/ra_mbe/src/subtree_source.rs b/crates/ra_mbe/src/subtree_source.rs
@@ -145,7 +145,7 @@ fn convert_ident(ident: &tt::Ident) -> TtToken {
     TtToken { kind, is_joint_to_next: false, text: ident.text.clone() }
 }
 
-fn convert_punct(p: &tt::Punct) -> TtToken {
+fn convert_punct(p: tt::Punct) -> TtToken {
     let kind = match p.char {
         // lexer may produce compound tokens for these ones
         '.' => T![.],
@@ -167,6 +167,6 @@ fn convert_leaf(leaf: &tt::Leaf) -> TtToken {
     match leaf {
         tt::Leaf::Literal(l) => convert_literal(l),
         tt::Leaf::Ident(ident) => convert_ident(ident),
-        tt::Leaf::Punct(punct) => convert_punct(punct),
+        tt::Leaf::Punct(punct) => convert_punct(*punct),
     }
 }
diff --git a/crates/ra_mbe/src/tt_cursor.rs b/crates/ra_mbe/src/tt_cursor.rs
@@ -170,20 +170,20 @@ impl<'a> TtCursor<'a> {
         }
     }
 
-    fn eat_punct3(&mut self, p: &tt::Punct) -> Option<SmallVec<[tt::Punct; 3]>> {
+    fn eat_punct3(&mut self, p: tt::Punct) -> Option<SmallVec<[tt::Punct; 3]>> {
         let sec = *self.eat_punct()?;
         let third = *self.eat_punct()?;
-        Some(smallvec![*p, sec, third])
+        Some(smallvec![p, sec, third])
     }
 
-    fn eat_punct2(&mut self, p: &tt::Punct) -> Option<SmallVec<[tt::Punct; 3]>> {
+    fn eat_punct2(&mut self, p: tt::Punct) -> Option<SmallVec<[tt::Punct; 3]>> {
         let sec = *self.eat_punct()?;
-        Some(smallvec![*p, sec])
+        Some(smallvec![p, sec])
     }
 
     fn eat_multi_char_punct<'b, I>(
         &mut self,
-        p: &tt::Punct,
+        p: tt::Punct,
         iter: &mut TokenPeek<'b, I>,
     ) -> Option<SmallVec<[tt::Punct; 3]>>
     where
@@ -250,7 +250,7 @@ impl<'a> TtCursor<'a> {
                 // But at this phase, some punct still is jointed.
                 // So we by pass that check here.
                 let mut peekable = TokenPeek::new(self.subtree.token_trees[self.pos..].iter());
-                let puncts = self.eat_multi_char_punct(punct, &mut peekable);
+                let puncts = self.eat_multi_char_punct(*punct, &mut peekable);
                 let puncts = puncts.unwrap_or_else(|| smallvec![*punct]);
 
                 Some(crate::Separator::Puncts(puncts))
@@ -292,7 +292,7 @@ where
         TokenPeek { iter: itertools::multipeek(iter) }
     }
 
-    pub fn current_punct2(&mut self, p: &tt::Punct) -> Option<((char, char), bool)> {
+    pub fn current_punct2(&mut self, p: tt::Punct) -> Option<((char, char), bool)> {
         if p.spacing != tt::Spacing::Joint {
             return None;
         }
@@ -302,7 +302,7 @@ where
         Some(((p.char, p1.char), p1.spacing == tt::Spacing::Joint))
     }
 
-    pub fn current_punct3(&mut self, p: &tt::Punct) -> Option<((char, char, char), bool)> {
+    pub fn current_punct3(&mut self, p: tt::Punct) -> Option<((char, char, char), bool)> {
         self.current_punct2(p).and_then(|((p0, p1), last_joint)| {
             if !last_joint {
                 None

Original file line number	Diff line number	Diff line change
`@@ -34,8 +34,8 @@ impl AdtDef {`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`impl Struct {`
`37`		`- pub(crate) fn variant_data(&self, db: &impl DefDatabase) -> Arc<VariantData> {`
`38`		`- db.struct_data(*self).variant_data.clone()`
	`37`	`+ pub(crate) fn variant_data(self, db: &impl DefDatabase) -> Arc<VariantData> {`
	`38`	`+ db.struct_data(self).variant_data.clone()`
`39`	`39`	`}`
`40`	`40`	`}`
`41`	`41`
`@@ -69,7 +69,7 @@ fn variants(enum_def: &ast::EnumDef) -> impl Iterator<Item = &ast::EnumVariant>`
`69`	`69`
`70`	`70`	`impl EnumVariant {`
`71`	`71`	`pub(crate) fn source_impl(`
`72`		`- &self,`
	`72`	`+ self,`
`73`	`73`	`db: &(impl DefDatabase + AstDatabase),`
`74`	`74`	`) -> Source<TreeArc<ast::EnumVariant>> {`
`75`	`75`	`let src = self.parent.source(db);`
`@@ -81,7 +81,7 @@ impl EnumVariant {`
`81`	`81`	`.to_owned();`
`82`	`82`	`Source { file_id: src.file_id, ast }`
`83`	`83`	`}`
`84`		`- pub(crate) fn variant_data(&self, db: &impl DefDatabase) -> Arc<VariantData> {`
	`84`	`+ pub(crate) fn variant_data(self, db: &impl DefDatabase) -> Arc<VariantData> {`
`85`	`85`	`db.enum_data(self.parent).variants[self.id].variant_data.clone()`
`86`	`86`	`}`
`87`	`87`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {`
`31`	`31`	`let body = self.func.body(db);`
`32`	`32`	`for e in body.exprs() {`
`33`	`33`	`if let (id, Expr::StructLit { path, fields, spread }) = e {`
`34`		`- self.validate_struct_literal(id, path, fields, spread, db);`
	`34`	`+ self.validate_struct_literal(id, path, fields, *spread, db);`
`35`	`35`	`}`
`36`	`36`	`}`
`37`	`37`	`}`
`@@ -41,7 +41,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {`
`41`	`41`	`id: ExprId,`
`42`	`42`	`_path: &Option<Path>,`
`43`	`43`	`fields: &[StructLitField],`
`44`		`- spread: &Option<ExprId>,`
	`44`	`+ spread: Option<ExprId>,`
`45`	`45`	`db: &impl HirDatabase,`
`46`	`46`	`) {`
`47`	`47`	`if spread.is_some() {`
Original file line number	Diff line number	Diff line change
`@@ -359,8 +359,8 @@ impl AstItemDef<ast::TypeAliasDef> for TypeAliasId {`
`359`	`359`	`}`
`360`	`360`
`361`	`361`	`impl MacroCallId {`
`362`		`- pub fn debug_dump(&self, db: &impl AstDatabase) -> String {`
`363`		`- let loc = self.clone().loc(db);`
	`362`	`+ pub fn debug_dump(self, db: &impl AstDatabase) -> String {`
	`363`	`+ let loc = self.loc(db);`
`364`	`364`	`let node = loc.ast_id.to_node(db);`
`365`	`365`	`let syntax_str = node.syntax().text().chunks().collect::<Vec<_>>().join(" ");`
`366`	`366`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ impl CrateImplBlocks {`
`58`	`58`
`59`	`59`	`pub fn lookup_impl_blocks_for_trait<'a>(`
`60`	`60`	`&'a self,`
`61`		`- tr: &Trait,`
	`61`	`+ tr: Trait,`
`62`	`62`	`) -> impl Iterator<Item = ImplBlock> + 'a {`
`63`	`63`	`self.impls_by_trait.get(&tr).into_iter().flat_map(\|i\| i.iter()).map(`
`64`	`64`	`move \|(module_id, impl_id)\| {`
`@@ -68,8 +68,8 @@ impl CrateImplBlocks {`
`68`	`68`	`)`
`69`	`69`	`}`
`70`	`70`
`71`		`- fn collect_recursive(&mut self, db: &impl HirDatabase, module: &Module) {`
`72`		`- let module_impl_blocks = db.impls_in_module(module.clone());`
	`71`	`+ fn collect_recursive(&mut self, db: &impl HirDatabase, module: Module) {`
	`72`	`+ let module_impl_blocks = db.impls_in_module(module);`
`73`	`73`
`74`	`74`	`for (impl_id, _) in module_impl_blocks.impls.iter() {`
`75`	`75`	`let impl_block = ImplBlock::from_id(module_impl_blocks.module, impl_id);`
`@@ -94,7 +94,7 @@ impl CrateImplBlocks {`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`for child in module.children(db) {`
`97`		`- self.collect_recursive(db, &child);`
	`97`	`+ self.collect_recursive(db, child);`
`98`	`98`	`}`
`99`	`99`	`}`
`100`	`100`
`@@ -108,7 +108,7 @@ impl CrateImplBlocks {`
`108`	`108`	`impls_by_trait: FxHashMap::default(),`
`109`	`109`	`};`
`110`	`110`	`if let Some(module) = krate.root_module(db) {`
`111`		`- crate_impl_blocks.collect_recursive(db, &module);`
	`111`	`+ crate_impl_blocks.collect_recursive(db, module);`
`112`	`112`	`}`
`113`	`113`	`Arc::new(crate_impl_blocks)`
`114`	`114`	`}`
Original file line number	Diff line number	Diff line change
`@@ -131,7 +131,7 @@ impl IntTy {`
`131`	`131`	`IntTy { signedness: Signedness::Unsigned, bitness: IntBitness::X128 }`
`132`	`132`	`}`
`133`	`133`
`134`		`- pub(crate) fn ty_to_string(&self) -> &'static str {`
	`134`	`+ pub(crate) fn ty_to_string(self) -> &'static str {`
`135`	`135`	`match (self.signedness, self.bitness) {`
`136`	`136`	`(Signedness::Signed, IntBitness::Xsize) => "isize",`
`137`	`137`	`(Signedness::Signed, IntBitness::X8) => "i8",`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ pub(crate) fn impls_for_trait_query(`
`50`	`50`	`impls.extend(db.impls_for_trait(dep.krate, trait_).iter());`
`51`	`51`	`}`
`52`	`52`	`let crate_impl_blocks = db.impls_in_crate(krate);`
`53`		`- impls.extend(crate_impl_blocks.lookup_impl_blocks_for_trait(&trait_));`
	`53`	`+ impls.extend(crate_impl_blocks.lookup_impl_blocks_for_trait(trait_));`
`54`	`54`	`impls.into_iter().collect::<Vec<_>>().into()`
`55`	`55`	`}`
`56`	`56`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ fn impls_for_trait(`
`65`	`65`
`66`	`66`	`Some(`
`67`	`67`	`impls`
`68`		`- .lookup_impl_blocks_for_trait(&tr)`
	`68`	`+ .lookup_impl_blocks_for_trait(tr)`
`69`	`69`	`.map(\|imp\| NavigationTarget::from_impl_block(db, imp))`
`70`	`70`	`.collect(),`
`71`	`71`	`)`
Original file line number	Diff line number	Diff line change
`@@ -213,7 +213,7 @@ impl RunningLineCol {`
`213`	`213`	`self.col_adjust = TextUnit::from(0);`
`214`	`214`	`}`
`215`	`215`
`216`		`- fn adjust_col(&mut self, range: &TextRange) {`
	`216`	`+ fn adjust_col(&mut self, range: TextRange) {`
`217`	`217`	`self.col_adjust += range.len() - TextUnit::from(1);`
`218`	`218`	`}`
`219`	`219`	`}`
`@@ -244,7 +244,7 @@ pub fn translate_offset_with_edit(`
`244`	`244`	`let clamp = offset.min(x.start());`
`245`	`245`	`return res.to_line_col(clamp);`
`246`	`246`	`} else {`
`247`		`- res.adjust_col(x);`
	`247`	`+ res.adjust_col(*x);`
`248`	`248`	`}`
`249`	`249`	`}`
`250`	`250`	`}`
Original file line number	Diff line number	Diff line change
`@@ -145,7 +145,7 @@ fn convert_ident(ident: &tt::Ident) -> TtToken {`
`145`	`145`	`TtToken { kind, is_joint_to_next: false, text: ident.text.clone() }`
`146`	`146`	`}`
`147`	`147`
`148`		`-fn convert_punct(p: &tt::Punct) -> TtToken {`
	`148`	`+fn convert_punct(p: tt::Punct) -> TtToken {`
`149`	`149`	`let kind = match p.char {`
`150`	`150`	`// lexer may produce compound tokens for these ones`
`151`	`151`	`'.' => T![.],`
`@@ -167,6 +167,6 @@ fn convert_leaf(leaf: &tt::Leaf) -> TtToken {`
`167`	`167`	`match leaf {`
`168`	`168`	`tt::Leaf::Literal(l) => convert_literal(l),`
`169`	`169`	`tt::Leaf::Ident(ident) => convert_ident(ident),`
`170`		`- tt::Leaf::Punct(punct) => convert_punct(punct),`
	`170`	`+ tt::Leaf::Punct(punct) => convert_punct(*punct),`
`171`	`171`	`}`
`172`	`172`	`}`