57 files changed, 694 insertions, 430 deletions
diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
index 7549e998b..ae9dccce9 100644
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -108,9 +108,6 @@ jobs:
      with:
        node-version: 12.x
-    - name: Print current revision
-      run: git describe --tags
    - name: Dist
      if: github.ref == 'refs/heads/release'
      run: cargo xtask dist --client 0.2.$GITHUB_RUN_NUMBER
diff --git a/crates/base_db/src/input.rs b/crates/base_db/src/input.rs
index d0def2181..e9e8dfc2e 100644
--- a/crates/base_db/src/input.rs
+++ b/crates/base_db/src/input.rs
@@ -410,7 +410,7 @@ impl CrateId {
 impl CrateData {
    fn add_dep(&mut self, name: CrateName, crate_id: CrateId) {
-        self.dependencies.push(Dependency { name, crate_id })
+        self.dependencies.push(Dependency { crate_id, name })
    }
 }
diff --git a/crates/cfg/src/dnf.rs b/crates/cfg/src/dnf.rs
index 30f4bcdf7..75ded9aa1 100644
--- a/crates/cfg/src/dnf.rs
+++ b/crates/cfg/src/dnf.rs
@@ -255,9 +255,9 @@ impl Builder {
 fn make_dnf(expr: CfgExpr) -> CfgExpr {
    match expr {
        CfgExpr::Invalid | CfgExpr::Atom(_) | CfgExpr::Not(_) => expr,
-        CfgExpr::Any(e) => CfgExpr::Any(e.into_iter().map(|expr| make_dnf(expr)).collect()),
+        CfgExpr::Any(e) => CfgExpr::Any(e.into_iter().map(make_dnf).collect()),
        CfgExpr::All(e) => {
-            let e = e.into_iter().map(|expr| make_nnf(expr)).collect::<Vec<_>>();
+            let e = e.into_iter().map(make_nnf).collect::<Vec<_>>();
            CfgExpr::Any(distribute_conj(&e))
        }
@@ -300,8 +300,8 @@ fn distribute_conj(conj: &[CfgExpr]) -> Vec<CfgExpr> {
 fn make_nnf(expr: CfgExpr) -> CfgExpr {
    match expr {
        CfgExpr::Invalid | CfgExpr::Atom(_) => expr,
-        CfgExpr::Any(expr) => CfgExpr::Any(expr.into_iter().map(|expr| make_nnf(expr)).collect()),
+        CfgExpr::Any(expr) => CfgExpr::Any(expr.into_iter().map(make_nnf).collect()),
-        CfgExpr::All(expr) => CfgExpr::All(expr.into_iter().map(|expr| make_nnf(expr)).collect()),
+        CfgExpr::All(expr) => CfgExpr::All(expr.into_iter().map(make_nnf).collect()),
        CfgExpr::Not(operand) => match *operand {
            CfgExpr::Invalid | CfgExpr::Atom(_) => CfgExpr::Not(operand.clone()), // Original negated expr
            CfgExpr::Not(expr) => {
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index e34be7e42..e3ac37e4c 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -213,7 +213,7 @@ impl Crate {
                Some(TokenTree::Leaf(Leaf::Literal(Literal{ref text, ..}))) => Some(text),
                _ => None
            }
-        }).flat_map(|t| t).next();
+        }).flatten().next();
        doc_url.map(|s| s.trim_matches('"').trim_end_matches('/').to_owned() + "/")
    }
@@ -2068,7 +2068,10 @@ impl Type {
                match pred {
                    WhereClause::Implemented(trait_ref) => {
                        cb(type_.clone());
-                        walk_substs(db, type_, &trait_ref.substitution, cb);
+                        // skip the self type. it's likely the type we just got the bounds from
+                        for ty in trait_ref.substitution.iter().skip(1) {
+                            walk_type(db, &type_.derived(ty.clone()), cb);
+                        }
                    }
                    _ => (),
                }
diff --git a/crates/hir_def/src/attr.rs b/crates/hir_def/src/attr.rs
index 2c10f46d8..52a2bce9b 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -638,7 +638,7 @@ fn collect_attrs(
    owner: &dyn ast::AttrsOwner,
 ) -> impl Iterator<Item = Either<ast::Attr, ast::Comment>> {
    let (inner_attrs, inner_docs) = inner_attributes(owner.syntax())
-        .map_or((None, None), |(attrs, docs)| ((Some(attrs), Some(docs))));
+        .map_or((None, None), |(attrs, docs)| (Some(attrs), Some(docs)));
    let outer_attrs = owner.attrs().filter(|attr| attr.excl_token().is_none());
    let attrs = outer_attrs
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 46a3c60cd..28b73c3a1 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -1467,12 +1467,13 @@ impl ModCollector<'_, '_> {
            },
        ) {
            Ok(Ok(macro_call_id)) => {
-                self.def_collector.unexpanded_macros.push(MacroDirective {
+                // Legacy macros need to be expanded immediately, so that any macros they produce
-                    module_id: self.module_id,
+                // are in scope.
-                    ast_id,
+                self.def_collector.collect_macro_expansion(
-                    legacy: Some(macro_call_id),
+                    self.module_id,
-                    depth: self.macro_depth + 1,
+                    macro_call_id,
-                });
+                    self.macro_depth + 1,
+                );
                return;
            }
diff --git a/crates/hir_def/src/nameres/tests/macros.rs b/crates/hir_def/src/nameres/tests/macros.rs
index d59d3c0db..6d3cb8d7a 100644
--- a/crates/hir_def/src/nameres/tests/macros.rs
+++ b/crates/hir_def/src/nameres/tests/macros.rs
@@ -713,6 +713,27 @@ b! { static = #[] ();}
 }
 #[test]
+fn macros_defining_macros() {
+    check(
+        r#"
+macro_rules! item {
+    ($item:item) => { $item }
+}
+item! {
+    macro_rules! indirect_macro { () => { struct S {} } }
+}
+indirect_macro!();
+    "#,
+        expect![[r#"
+            crate
+            S: t
+        "#]],
+    );
+}
+#[test]
 fn resolves_proc_macros() {
    check(
        r"
diff --git a/crates/hir_def/src/resolver.rs b/crates/hir_def/src/resolver.rs
index 4a2d1c087..04ea9c5d7 100644
--- a/crates/hir_def/src/resolver.rs
+++ b/crates/hir_def/src/resolver.rs
@@ -472,7 +472,7 @@ impl Scope {
            }
            Scope::ExprScope(scope) => {
                if let Some((label, name)) = scope.expr_scopes.label(scope.scope_id) {
-                    f(name.clone(), ScopeDef::Label(label))
+                    f(name, ScopeDef::Label(label))
                }
                scope.expr_scopes.entries(scope.scope_id).iter().for_each(|e| {
                    f(e.name().clone(), ScopeDef::Local(e.pat()));
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index 2748e25cf..fc73e435b 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -173,7 +173,7 @@ fn macro_arg_text(db: &dyn AstDatabase, id: MacroCallId) -> Option<GreenNode> {
    };
    let loc = db.lookup_intern_macro(id);
    let arg = loc.kind.arg(db)?;
-    Some(arg.green().to_owned())
+    Some(arg.green())
 }
 fn macro_arg(db: &dyn AstDatabase, id: MacroCallId) -> Option<Arc<(tt::Subtree, mbe::TokenMap)>> {
diff --git a/crates/hir_expand/src/name.rs b/crates/hir_expand/src/name.rs
index 43de9edd6..0aeea48d5 100644
--- a/crates/hir_expand/src/name.rs
+++ b/crates/hir_expand/src/name.rs
@@ -48,9 +48,8 @@ impl Name {
    /// Resolve a name from the text of token.
    fn resolve(raw_text: &str) -> Name {
-        let raw_start = "r#";
+        if let Some(text) = raw_text.strip_prefix("r#") {
-        if raw_text.starts_with(raw_start) {
+            Name::new_text(SmolStr::new(text))
-            Name::new_text(SmolStr::new(&raw_text[raw_start.len()..]))
        } else {
            Name::new_text(raw_text.into())
        }
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index 3845009ae..9d3b79be3 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -571,13 +571,22 @@ impl HirDisplay for Ty {
                        write!(f, "{}", param_data.name.clone().unwrap_or_else(Name::missing))?
                    }
                    TypeParamProvenance::ArgumentImplTrait => {
-                        let bounds = f.db.generic_predicates_for_param(id);
                        let substs = Substitution::type_params_for_generics(f.db, &generics);
-                        write_bounds_like_dyn_trait_with_prefix(
+                        let bounds = f
-                            "impl",
+                            .db
-                            &bounds.iter().map(|b| b.clone().subst(&substs)).collect::<Vec<_>>(),
+                            .generic_predicates(id.parent)
-                            f,
+                            .into_iter()
-                        )?;
+                            .map(|pred| pred.clone().subst(&substs))
+                            .filter(|wc| match &wc {
+                                WhereClause::Implemented(tr) => tr.self_type_parameter() == self,
+                                WhereClause::AliasEq(AliasEq {
+                                    alias: AliasTy::Projection(proj),
+                                    ty: _,
+                                }) => proj.self_type_parameter() == self,
+                                _ => false,
+                            })
+                            .collect::<Vec<_>>();
+                        write_bounds_like_dyn_trait_with_prefix("impl", &bounds, f)?;
                    }
                }
            }
diff --git a/crates/hir_ty/src/infer/pat.rs b/crates/hir_ty/src/infer/pat.rs
index befa0d69b..ec491648f 100644
--- a/crates/hir_ty/src/infer/pat.rs
+++ b/crates/hir_ty/src/infer/pat.rs
@@ -38,7 +38,7 @@ impl<'a> InferenceContext<'a> {
        let field_tys = def.map(|it| self.db.field_types(it)).unwrap_or_default();
        let (pre, post) = match ellipsis {
            Some(idx) => subpats.split_at(idx),
-            None => (&subpats[..], &[][..]),
+            None => (subpats, &[][..]),
        };
        let post_idx_offset = field_tys.iter().count() - post.len();
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index c46529879..ad908f957 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -106,6 +106,10 @@ impl ProjectionTy {
        }
    }
+    pub fn self_type_parameter(&self) -> &Ty {
+        &self.substitution[0]
+    }
    fn trait_(&self, db: &dyn HirDatabase) -> TraitId {
        match from_assoc_type_id(self.associated_ty_id).lookup(db.upcast()).container {
            AssocContainerId::TraitId(it) => it,
@@ -936,10 +940,19 @@ impl Ty {
                let param_data = &generic_params.types[id.local_id];
                match param_data.provenance {
                    hir_def::generics::TypeParamProvenance::ArgumentImplTrait => {
+                        let substs = Substitution::type_params(db, id.parent);
                        let predicates = db
-                            .generic_predicates_for_param(id)
+                            .generic_predicates(id.parent)
                            .into_iter()
-                            .map(|pred| pred.value.clone())
+                            .map(|pred| pred.clone().subst(&substs))
+                            .filter(|wc| match &wc {
+                                WhereClause::Implemented(tr) => tr.self_type_parameter() == self,
+                                WhereClause::AliasEq(AliasEq {
+                                    alias: AliasTy::Projection(proj),
+                                    ty: _,
+                                }) => proj.self_type_parameter() == self,
+                                _ => false,
+                            })
                            .collect_vec();
                        Some(predicates)
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs
index cbbb535e5..fd451a823 100644
--- a/crates/hir_ty/src/lower.rs
+++ b/crates/hir_ty/src/lower.rs
@@ -189,7 +189,10 @@ impl<'a> TyLoweringContext<'a> {
                let self_ty =
                    TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)).intern(&Interner);
                let predicates = self.with_shifted_in(DebruijnIndex::ONE, |ctx| {
-                    bounds.iter().flat_map(|b| ctx.lower_type_bound(b, self_ty.clone())).collect()
+                    bounds
+                        .iter()
+                        .flat_map(|b| ctx.lower_type_bound(b, self_ty.clone(), false))
+                        .collect()
                });
                TyKind::Dyn(predicates).intern(&Interner)
            }
@@ -666,6 +669,7 @@ impl<'a> TyLoweringContext<'a> {
    pub(crate) fn lower_where_predicate(
        &'a self,
        where_predicate: &'a WherePredicate,
+        ignore_bindings: bool,
    ) -> impl Iterator<Item = WhereClause> + 'a {
        match where_predicate {
            WherePredicate::ForLifetime { target, bound, .. }
@@ -688,7 +692,9 @@ impl<'a> TyLoweringContext<'a> {
                        .intern(&Interner)
                    }
                };
-                self.lower_type_bound(bound, self_ty).collect::<Vec<_>>().into_iter()
+                self.lower_type_bound(bound, self_ty, ignore_bindings)
+                    .collect::<Vec<_>>()
+                    .into_iter()
            }
            WherePredicate::Lifetime { .. } => vec![].into_iter(),
        }
@@ -698,6 +704,7 @@ impl<'a> TyLoweringContext<'a> {
        &'a self,
        bound: &'a TypeBound,
        self_ty: Ty,
+        ignore_bindings: bool,
    ) -> impl Iterator<Item = WhereClause> + 'a {
        let mut bindings = None;
        let trait_ref = match bound {
@@ -711,6 +718,7 @@ impl<'a> TyLoweringContext<'a> {
        trait_ref.into_iter().chain(
            bindings
                .into_iter()
+                .filter(move |_| !ignore_bindings)
                .flat_map(move |tr| self.assoc_type_bindings_from_type_bound(bound, tr)),
        )
    }
@@ -755,6 +763,7 @@ impl<'a> TyLoweringContext<'a> {
                    preds.extend(self.lower_type_bound(
                        bound,
                        TyKind::Alias(AliasTy::Projection(projection_ty.clone())).intern(&Interner),
+                        false,
                    ));
                }
                preds
@@ -766,7 +775,7 @@ impl<'a> TyLoweringContext<'a> {
        let self_ty =
            TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)).intern(&Interner);
        let predicates = self.with_shifted_in(DebruijnIndex::ONE, |ctx| {
-            bounds.iter().flat_map(|b| ctx.lower_type_bound(b, self_ty.clone())).collect()
+            bounds.iter().flat_map(|b| ctx.lower_type_bound(b, self_ty.clone(), false)).collect()
        });
        ReturnTypeImplTrait { bounds: Binders::new(1, predicates) }
    }
@@ -896,7 +905,9 @@ pub(crate) fn generic_predicates_for_param_query(
            },
            WherePredicate::Lifetime { .. } => false,
        })
-        .flat_map(|pred| ctx.lower_where_predicate(pred).map(|p| Binders::new(generics.len(), p)))
+        .flat_map(|pred| {
+            ctx.lower_where_predicate(pred, true).map(|p| Binders::new(generics.len(), p))
+        })
        .collect()
 }
@@ -918,7 +929,7 @@ pub(crate) fn trait_environment_query(
    let mut traits_in_scope = Vec::new();
    let mut clauses = Vec::new();
    for pred in resolver.where_predicates_in_scope() {
-        for pred in ctx.lower_where_predicate(pred) {
+        for pred in ctx.lower_where_predicate(pred, false) {
            if let WhereClause::Implemented(tr) = &pred {
                traits_in_scope.push((tr.self_type_parameter().clone(), tr.hir_trait_id()));
            }
@@ -946,8 +957,7 @@ pub(crate) fn trait_environment_query(
        let substs = Substitution::type_params(db, trait_id);
        let trait_ref = TraitRef { trait_id: to_chalk_trait_id(trait_id), substitution: substs };
        let pred = WhereClause::Implemented(trait_ref);
-        let program_clause: chalk_ir::ProgramClause<Interner> =
+        let program_clause: chalk_ir::ProgramClause<Interner> = pred.to_chalk(db).cast(&Interner);
-            pred.clone().to_chalk(db).cast(&Interner);
        clauses.push(program_clause.into_from_env_clause(&Interner));
    }
@@ -967,7 +977,9 @@ pub(crate) fn generic_predicates_query(
    let generics = generics(db.upcast(), def);
    resolver
        .where_predicates_in_scope()
-        .flat_map(|pred| ctx.lower_where_predicate(pred).map(|p| Binders::new(generics.len(), p)))
+        .flat_map(|pred| {
+            ctx.lower_where_predicate(pred, false).map(|p| Binders::new(generics.len(), p))
+        })
        .collect()
 }
diff --git a/crates/hir_ty/src/tests.rs b/crates/hir_ty/src/tests.rs
index 0a4141e69..ad283c1e0 100644
--- a/crates/hir_ty/src/tests.rs
+++ b/crates/hir_ty/src/tests.rs
@@ -369,3 +369,72 @@ fn check_infer_with_mismatches(ra_fixture: &str, expect: Expect) {
    actual.push('\n');
    expect.assert_eq(&actual);
 }
+#[test]
+fn salsa_bug() {
+    let (mut db, pos) = TestDB::with_position(
+        "
+        //- /lib.rs
+        trait Index {
+            type Output;
+        }
+        type Key<S: UnificationStoreBase> = <S as UnificationStoreBase>::Key;
+        pub trait UnificationStoreBase: Index<Output = Key<Self>> {
+            type Key;
+            fn len(&self) -> usize;
+        }
+        pub trait UnificationStoreMut: UnificationStoreBase {
+            fn push(&mut self, value: Self::Key);
+        }
+        fn main() {
+            let x = 1;
+            x.push(1);$0
+        }
+    ",
+    );
+    let module = db.module_for_file(pos.file_id);
+    let crate_def_map = module.def_map(&db);
+    visit_module(&db, &crate_def_map, module.local_id, &mut |def| {
+        db.infer(def);
+    });
+    let new_text = "
+        //- /lib.rs
+        trait Index {
+            type Output;
+        }
+        type Key<S: UnificationStoreBase> = <S as UnificationStoreBase>::Key;
+        pub trait UnificationStoreBase: Index<Output = Key<Self>> {
+            type Key;
+            fn len(&self) -> usize;
+        }
+        pub trait UnificationStoreMut: UnificationStoreBase {
+            fn push(&mut self, value: Self::Key);
+        }
+        fn main() {
+            let x = 1;
+            x.push(1);
+        }
+    "
+    .to_string();
+    db.set_file_text(pos.file_id, Arc::new(new_text));
+    let module = db.module_for_file(pos.file_id);
+    let crate_def_map = module.def_map(&db);
+    visit_module(&db, &crate_def_map, module.local_id, &mut |def| {
+        db.infer(def);
+    });
+}
diff --git a/crates/hir_ty/src/tests/traits.rs b/crates/hir_ty/src/tests/traits.rs
index 8f2bdffc0..37cd04c6f 100644
--- a/crates/hir_ty/src/tests/traits.rs
+++ b/crates/hir_ty/src/tests/traits.rs
@@ -2272,6 +2272,56 @@ fn test<T, U>() where T: Trait<U::Item>, U: Trait<T::Item> {
 }
 #[test]
+fn unselected_projection_in_trait_env_cycle_3() {
+    // this is a cycle for rustc; we currently accept it
+    check_types(
+        r#"
+//- /main.rs
+trait Trait {
+    type Item;
+    type OtherItem;
+}
+fn test<T>() where T: Trait<OtherItem = T::Item> {
+    let x: T::Item = no_matter;
+}                   //^ Trait::Item<T>
+"#,
+    );
+}
+#[test]
+fn unselected_projection_in_trait_env_no_cycle() {
+    // this is not a cycle
+    check_types(
+        r#"
+//- /main.rs
+trait Index {
+    type Output;
+}
+type Key<S: UnificationStoreBase> = <S as UnificationStoreBase>::Key;
+pub trait UnificationStoreBase: Index<Output = Key<Self>> {
+    type Key;
+    fn len(&self) -> usize;
+}
+pub trait UnificationStoreMut: UnificationStoreBase {
+    fn push(&mut self, value: Self::Key);
+}
+fn test<T>(t: T) where T: UnificationStoreMut {
+    let x;
+    t.push(x);
+    let y: Key<T>;
+    (x, y);
+}      //^ (UnificationStoreBase::Key<T>, UnificationStoreBase::Key<T>)
+"#,
+    );
+}
+#[test]
 fn inline_assoc_type_bounds_1() {
    check_types(
        r#"
diff --git a/crates/hir_ty/src/traits/chalk.rs b/crates/hir_ty/src/traits/chalk.rs
index 734679414..944145603 100644
--- a/crates/hir_ty/src/traits/chalk.rs
+++ b/crates/hir_ty/src/traits/chalk.rs
@@ -395,7 +395,7 @@ pub(crate) fn associated_ty_data_query(
    let bounds = type_alias_data
        .bounds
        .iter()
-        .flat_map(|bound| ctx.lower_type_bound(bound, self_ty.clone()))
+        .flat_map(|bound| ctx.lower_type_bound(bound, self_ty.clone(), false))
        .filter_map(|pred| generic_predicate_to_inline_bound(db, &pred, &self_ty))
        .map(|bound| make_binders(bound.shifted_in(&Interner), 0))
        .collect();
diff --git a/crates/ide/src/extend_selection.rs b/crates/ide/src/extend_selection.rs
index e187243cb..5201ce587 100644
--- a/crates/ide/src/extend_selection.rs
+++ b/crates/ide/src/extend_selection.rs
@@ -263,11 +263,10 @@ fn extend_list_item(node: &SyntaxNode) -> Option<TextRange> {
    ) -> Option<SyntaxToken> {
        node.siblings_with_tokens(dir)
            .skip(1)
-            .skip_while(|node| match node {
+            .find(|node| match node {
-                NodeOrToken::Node(_) => false,
+                NodeOrToken::Node(_) => true,
-                NodeOrToken::Token(it) => is_single_line_ws(it),
+                NodeOrToken::Token(it) => !is_single_line_ws(it),
            })
-            .next()
            .and_then(|it| it.into_token())
            .filter(|node| node.kind() == delimiter_kind)
    }
diff --git a/crates/ide_assists/src/handlers/convert_comment_block.rs b/crates/ide_assists/src/handlers/convert_comment_block.rs
index cdc45fc42..9dc3ee28f 100644
--- a/crates/ide_assists/src/handlers/convert_comment_block.rs
+++ b/crates/ide_assists/src/handlers/convert_comment_block.rs
@@ -1,5 +1,4 @@
 use itertools::Itertools;
-use std::convert::identity;
 use syntax::{
    ast::{
        self,
@@ -140,7 +139,7 @@ fn relevant_line_comments(comment: &ast::Comment) -> Vec<Comment> {
        .filter(|s| !skippable(s))
        .map(|not| not.into_token().and_then(Comment::cast).filter(same_prefix))
        .take_while(|opt_com| opt_com.is_some())
-        .filter_map(identity)
+        .flatten()
        .skip(1); // skip the first element so we don't duplicate it in next_comments
    let next_comments = comment
@@ -149,7 +148,7 @@ fn relevant_line_comments(comment: &ast::Comment) -> Vec<Comment> {
        .filter(|s| !skippable(s))
        .map(|not| not.into_token().and_then(Comment::cast).filter(same_prefix))
        .take_while(|opt_com| opt_com.is_some())
-        .filter_map(identity);
+        .flatten();
    let mut comments: Vec<_> = prev_comments.collect();
    comments.reverse();
diff --git a/crates/ide_assists/src/handlers/expand_glob_import.rs b/crates/ide_assists/src/handlers/expand_glob_import.rs
index 83aa11d52..98389e4f7 100644
--- a/crates/ide_assists/src/handlers/expand_glob_import.rs
+++ b/crates/ide_assists/src/handlers/expand_glob_import.rs
@@ -136,18 +136,13 @@ impl Refs {
                .into_iter()
                .filter(|r| {
                    if let Def::ModuleDef(ModuleDef::Trait(tr)) = r.def {
-                        if tr
+                        if tr.items(ctx.db()).into_iter().any(|ai| {
-                            .items(ctx.db())
+                            if let AssocItem::Function(f) = ai {
-                            .into_iter()
+                                Def::ModuleDef(ModuleDef::Function(f)).is_referenced_in(ctx)
-                            .find(|ai| {
+                            } else {
-                                if let AssocItem::Function(f) = *ai {
+                                false
-                                    Def::ModuleDef(ModuleDef::Function(f)).is_referenced_in(ctx)
+                            }
-                                } else {
+                        }) {
-                                    false
-                                }
-                            })
-                            .is_some()
-                        {
                            return true;
                        }
                    }
diff --git a/crates/ide_assists/src/handlers/qualify_path.rs b/crates/ide_assists/src/handlers/qualify_path.rs
index e7444f7db..f91770a76 100644
--- a/crates/ide_assists/src/handlers/qualify_path.rs
+++ b/crates/ide_assists/src/handlers/qualify_path.rs
@@ -536,6 +536,7 @@ fn main() {
    }
    #[test]
+    #[ignore = "FIXME: non-trait assoc items completion is unsupported yet, see FIXME in the import_assets.rs for more details"]
    fn associated_struct_const_unqualified() {
        check_assist(
            qualify_path,
diff --git a/crates/ide_assists/src/handlers/reorder_impl.rs b/crates/ide_assists/src/handlers/reorder_impl.rs
index edf4b0bfe..f976e73ad 100644
--- a/crates/ide_assists/src/handlers/reorder_impl.rs
+++ b/crates/ide_assists/src/handlers/reorder_impl.rs
@@ -95,7 +95,7 @@ fn compute_method_ranks(path: &ast::Path, ctx: &AssistContext) -> Option<FxHashM
                _ => None,
            })
            .enumerate()
-            .map(|(idx, func)| ((func.name(ctx.db()).to_string(), idx)))
+            .map(|(idx, func)| (func.name(ctx.db()).to_string(), idx))
            .collect(),
    )
 }
diff --git a/crates/ide_assists/src/handlers/replace_derive_with_manual_impl.rs b/crates/ide_assists/src/handlers/replace_derive_with_manual_impl.rs
index 88fe2fe90..4f0ef52ca 100644
--- a/crates/ide_assists/src/handlers/replace_derive_with_manual_impl.rs
+++ b/crates/ide_assists/src/handlers/replace_derive_with_manual_impl.rs
@@ -1,5 +1,5 @@
 use hir::ModuleDef;
-use ide_db::helpers::mod_path_to_ast;
+use ide_db::helpers::{import_assets::NameToImport, mod_path_to_ast};
 use ide_db::items_locator;
 use itertools::Itertools;
 use syntax::{
@@ -65,20 +65,24 @@ pub(crate) fn replace_derive_with_manual_impl(
    let current_module = ctx.sema.scope(annotated_name.syntax()).module()?;
    let current_crate = current_module.krate();
-    let found_traits =
+    let found_traits = items_locator::items_with_name(
-        items_locator::with_exact_name(&ctx.sema, current_crate, trait_token.text().to_string())
+        &ctx.sema,
-            .into_iter()
+        current_crate,
-            .filter_map(|item| match ModuleDef::from(item.as_module_def_id()?) {
+        NameToImport::Exact(trait_token.text().to_string()),
-                ModuleDef::Trait(trait_) => Some(trait_),
+        items_locator::AssocItemSearch::Exclude,
-                _ => None,
+        Some(items_locator::DEFAULT_QUERY_SEARCH_LIMIT),
-            })
+    )
-            .flat_map(|trait_| {
+    .filter_map(|item| match ModuleDef::from(item.as_module_def_id()?) {
-                current_module
+        ModuleDef::Trait(trait_) => Some(trait_),
-                    .find_use_path(ctx.sema.db, hir::ModuleDef::Trait(trait_))
+        _ => None,
-                    .as_ref()
+    })
-                    .map(mod_path_to_ast)
+    .flat_map(|trait_| {
-                    .zip(Some(trait_))
+        current_module
-            });
+            .find_use_path(ctx.sema.db, hir::ModuleDef::Trait(trait_))
+            .as_ref()
+            .map(mod_path_to_ast)
+            .zip(Some(trait_))
+    });
    let mut no_traits_found = true;
    for (trait_path, trait_) in found_traits.inspect(|_| no_traits_found = false) {
diff --git a/crates/ide_completion/src/completions/flyimport.rs b/crates/ide_completion/src/completions/flyimport.rs
index 08df2df3f..1ad017198 100644
--- a/crates/ide_completion/src/completions/flyimport.rs
+++ b/crates/ide_completion/src/completions/flyimport.rs
@@ -1,8 +1,10 @@
 //! Feature: completion with imports-on-the-fly
 //!
 //! When completing names in the current scope, proposes additional imports from other modules or crates,
-//! if they can be qualified in the scope and their name contains all symbols from the completion input
+//! if they can be qualified in the scope and their name contains all symbols from the completion input.
-//! (case-insensitive, in any order or places).
+//!
+//! To be considered applicable, the name must contain all input symbols in the given order, not necessarily adjacent.
+//! If any input symbol is not lowercased, the name must contain all symbols in exact case; otherwise the contaning is checked case-insensitively.
 //!
 //! ```
 //! fn main() {
@@ -942,9 +944,94 @@ mod foo {
 }
 fn main() {
-    bar::Ass$0
+    bar::ASS$0
 }"#,
            expect![[]],
        )
    }
+    #[test]
+    fn unqualified_assoc_items_are_omitted() {
+        check(
+            r#"
+mod something {
+    pub trait BaseTrait {
+        fn test_function() -> i32;
+    }
+    pub struct Item1;
+    pub struct Item2;
+    impl BaseTrait for Item1 {
+        fn test_function() -> i32 {
+            1
+        }
+    }
+    impl BaseTrait for Item2 {
+        fn test_function() -> i32 {
+            2
+        }
+    }
+}
+fn main() {
+    test_f$0
+}"#,
+            expect![[]],
+        )
+    }
+    #[test]
+    fn case_matters() {
+        check(
+            r#"
+mod foo {
+    pub const TEST_CONST: usize = 3;
+    pub fn test_function() -> i32 {
+        4
+    }
+}
+fn main() {
+    TE$0
+}"#,
+            expect![[r#"
+        ct foo::TEST_CONST
+    "#]],
+        );
+        check(
+            r#"
+mod foo {
+    pub const TEST_CONST: usize = 3;
+    pub fn test_function() -> i32 {
+        4
+    }
+}
+fn main() {
+    te$0
+}"#,
+            expect![[r#"
+        ct foo::TEST_CONST
+        fn test_function() (foo::test_function) fn() -> i32
+    "#]],
+        );
+        check(
+            r#"
+mod foo {
+    pub const TEST_CONST: usize = 3;
+    pub fn test_function() -> i32 {
+        4
+    }
+}
+fn main() {
+    Te$0
+}"#,
+            expect![[]],
+        );
+    }
 }
diff --git a/crates/ide_completion/src/completions/lifetime.rs b/crates/ide_completion/src/completions/lifetime.rs
index 628c1fb9b..5eeddf7a4 100644
--- a/crates/ide_completion/src/completions/lifetime.rs
+++ b/crates/ide_completion/src/completions/lifetime.rs
@@ -70,6 +70,16 @@ fn func<'lifetime>(foo: &'li$0) {}
 fn func<'lifetime>(foo: &'lifetime) {}
 "#,
        );
+        cov_mark::check!(completes_if_lifetime_without_idents);
+        check_edit(
+            "'lifetime",
+            r#"
+fn func<'lifetime>(foo: &'$0) {}
+"#,
+            r#"
+fn func<'lifetime>(foo: &'lifetime) {}
+"#,
+        );
    }
    #[test]
@@ -192,6 +202,27 @@ fn foo<'footime, 'lifetime: 'a$0>() {}
    }
    #[test]
+    fn check_label_edit() {
+        check_edit(
+            "'label",
+            r#"
+fn foo() {
+    'label: loop {
+        break '$0
+    }
+}
+"#,
+            r#"
+fn foo() {
+    'label: loop {
+        break 'label
+    }
+}
+"#,
+        );
+    }
+    #[test]
    fn complete_label_in_loop() {
        check(
            r#"
diff --git a/crates/ide_completion/src/context.rs b/crates/ide_completion/src/context.rs
index 67e2d6f6c..32f81aec1 100644
--- a/crates/ide_completion/src/context.rs
+++ b/crates/ide_completion/src/context.rs
@@ -255,6 +255,10 @@ impl<'a> CompletionContext<'a> {
        if kind == IDENT || kind == LIFETIME_IDENT || kind == UNDERSCORE || kind.is_keyword() {
            cov_mark::hit!(completes_if_prefix_is_keyword);
            self.original_token.text_range()
+        } else if kind == CHAR {
+            // assume we are completing a lifetime but the user has only typed the '
+            cov_mark::hit!(completes_if_lifetime_without_idents);
+            TextRange::at(self.original_token.text_range().start(), TextSize::from(1))
        } else {
            TextRange::empty(self.position.offset)
        }
@@ -471,7 +475,7 @@ impl<'a> CompletionContext<'a> {
        self.lifetime_syntax =
            find_node_at_offset(original_file, lifetime.syntax().text_range().start());
        if let Some(parent) = lifetime.syntax().parent() {
-            if parent.kind() == syntax::SyntaxKind::ERROR {
+            if parent.kind() == ERROR {
                return;
            }
diff --git a/crates/ide_completion/src/lib.rs b/crates/ide_completion/src/lib.rs
index 995970fca..5ac1cb48d 100644
--- a/crates/ide_completion/src/lib.rs
+++ b/crates/ide_completion/src/lib.rs
@@ -14,7 +14,10 @@ mod completions;
 use completions::flyimport::position_for_import;
 use ide_db::{
    base_db::FilePosition,
-    helpers::{import_assets::LocatedImport, insert_use::ImportScope},
+    helpers::{
+        import_assets::{LocatedImport, NameToImport},
+        insert_use::ImportScope,
+    },
    items_locator, RootDatabase,
 };
 use text_edit::TextEdit;
@@ -151,15 +154,19 @@ pub fn resolve_completion_edits(
    let current_module = ctx.sema.scope(position_for_import).module()?;
    let current_crate = current_module.krate();
-    let (import_path, item_to_import) =
+    let (import_path, item_to_import) = items_locator::items_with_name(
-        items_locator::with_exact_name(&ctx.sema, current_crate, imported_name)
+        &ctx.sema,
-            .into_iter()
+        current_crate,
-            .filter_map(|candidate| {
+        NameToImport::Exact(imported_name),
-                current_module
+        items_locator::AssocItemSearch::Include,
-                    .find_use_path_prefixed(db, candidate, config.insert_use.prefix_kind)
+        Some(items_locator::DEFAULT_QUERY_SEARCH_LIMIT),
-                    .zip(Some(candidate))
+    )
-            })
+    .filter_map(|candidate| {
-            .find(|(mod_path, _)| mod_path.to_string() == full_import_path)?;
+        current_module
+            .find_use_path_prefixed(db, candidate, config.insert_use.prefix_kind)
+            .zip(Some(candidate))
+    })
+    .find(|(mod_path, _)| mod_path.to_string() == full_import_path)?;
    let import =
        LocatedImport::new(import_path.clone(), item_to_import, item_to_import, Some(import_path));
diff --git a/crates/ide_completion/src/patterns.rs b/crates/ide_completion/src/patterns.rs
index cf5ef07b7..d82564381 100644
--- a/crates/ide_completion/src/patterns.rs
+++ b/crates/ide_completion/src/patterns.rs
@@ -71,7 +71,7 @@ fn test_has_block_expr_parent() {
 }
 pub(crate) fn has_bind_pat_parent(element: SyntaxElement) -> bool {
-    element.ancestors().find(|it| it.kind() == IDENT_PAT).is_some()
+    element.ancestors().any(|it| it.kind() == IDENT_PAT)
 }
 #[test]
 fn test_has_bind_pat_parent() {
diff --git a/crates/ide_db/src/helpers/import_assets.rs b/crates/ide_db/src/helpers/import_assets.rs
index 7c8844e95..1881c746f 100644
--- a/crates/ide_db/src/helpers/import_assets.rs
+++ b/crates/ide_db/src/helpers/import_assets.rs
@@ -61,7 +61,7 @@ pub struct FirstSegmentUnresolved {
 }
 /// A name that will be used during item lookups.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum NameToImport {
    /// Requires items with names that exactly match the given string, case-sensitive.
    Exact(String),
@@ -201,129 +201,101 @@ impl ImportAssets {
        sema: &Semantics<RootDatabase>,
        prefixed: Option<PrefixKind>,
    ) -> Vec<LocatedImport> {
-        let items_with_candidate_name = match self.name_to_import() {
+        let _p = profile::span("import_assets::search_for");
-            NameToImport::Exact(exact_name) => items_locator::with_exact_name(
-                sema,
-                self.module_with_candidate.krate(),
-                exact_name.clone(),
-            ),
-            // FIXME: ideally, we should avoid using `fst` for seacrhing trait imports for assoc items:
-            // instead, we need to look up all trait impls for a certain struct and search through them only
-            // see https://github.com/rust-analyzer/rust-analyzer/pull/7293#issuecomment-761585032
-            // and https://rust-lang.zulipchat.com/#narrow/stream/185405-t-compiler.2Fwg-rls-2.2E0/topic/Blanket.20trait.20impls.20lookup
-            // for the details
-            NameToImport::Fuzzy(fuzzy_name) => {
-                let (assoc_item_search, limit) = if self.import_candidate.is_trait_candidate() {
-                    (AssocItemSearch::AssocItemsOnly, None)
-                } else {
-                    (AssocItemSearch::Include, Some(DEFAULT_QUERY_SEARCH_LIMIT))
-                };
-                items_locator::with_similar_name(
-                    sema,
-                    self.module_with_candidate.krate(),
-                    fuzzy_name.clone(),
-                    assoc_item_search,
-                    limit,
-                )
-            }
-        };
        let scope_definitions = self.scope_definitions(sema);
-        self.applicable_defs(sema.db, prefixed, items_with_candidate_name)
-            .into_iter()
-            .filter(|import| import.import_path.len() > 1)
-            .filter(|import| !scope_definitions.contains(&ScopeDef::from(import.item_to_import)))
-            .sorted_by_key(|import| import.import_path.clone())
-            .collect()
-    }
-    fn scope_definitions(&self, sema: &Semantics<RootDatabase>) -> FxHashSet<ScopeDef> {
-        let mut scope_definitions = FxHashSet::default();
-        sema.scope(&self.candidate_node).process_all_names(&mut |_, scope_def| {
-            scope_definitions.insert(scope_def);
-        });
-        scope_definitions
-    }
-    fn name_to_import(&self) -> &NameToImport {
-        match &self.import_candidate {
-            ImportCandidate::Path(candidate) => &candidate.name,
-            ImportCandidate::TraitAssocItem(candidate)
-            | ImportCandidate::TraitMethod(candidate) => &candidate.assoc_item_name,
-        }
-    }
-    fn applicable_defs(
-        &self,
-        db: &RootDatabase,
-        prefixed: Option<PrefixKind>,
-        items_with_candidate_name: FxHashSet<ItemInNs>,
-    ) -> FxHashSet<LocatedImport> {
-        let _p = profile::span("import_assets::applicable_defs");
        let current_crate = self.module_with_candidate.krate();
        let mod_path = |item| {
-            get_mod_path(db, item_for_path_search(db, item)?, &self.module_with_candidate, prefixed)
+            get_mod_path(
+                sema.db,
+                item_for_path_search(sema.db, item)?,
+                &self.module_with_candidate,
+                prefixed,
+            )
        };
        match &self.import_candidate {
            ImportCandidate::Path(path_candidate) => {
-                path_applicable_imports(db, path_candidate, mod_path, items_with_candidate_name)
+                path_applicable_imports(sema, current_crate, path_candidate, mod_path)
+            }
+            ImportCandidate::TraitAssocItem(trait_candidate) => {
+                trait_applicable_items(sema, current_crate, trait_candidate, true, mod_path)
+            }
+            ImportCandidate::TraitMethod(trait_candidate) => {
+                trait_applicable_items(sema, current_crate, trait_candidate, false, mod_path)
            }
-            ImportCandidate::TraitAssocItem(trait_candidate) => trait_applicable_items(
-                db,
-                current_crate,
-                trait_candidate,
-                true,
-                mod_path,
-                items_with_candidate_name,
-            ),
-            ImportCandidate::TraitMethod(trait_candidate) => trait_applicable_items(
-                db,
-                current_crate,
-                trait_candidate,
-                false,
-                mod_path,
-                items_with_candidate_name,
-            ),
        }
+        .into_iter()
+        .filter(|import| import.import_path.len() > 1)
+        .filter(|import| !scope_definitions.contains(&ScopeDef::from(import.item_to_import)))
+        .sorted_by_key(|import| import.import_path.clone())
+        .collect()
+    }
+    fn scope_definitions(&self, sema: &Semantics<RootDatabase>) -> FxHashSet<ScopeDef> {
+        let _p = profile::span("import_assets::scope_definitions");
+        let mut scope_definitions = FxHashSet::default();
+        sema.scope(&self.candidate_node).process_all_names(&mut |_, scope_def| {
+            scope_definitions.insert(scope_def);
+        });
+        scope_definitions
    }
 }
 fn path_applicable_imports(
-    db: &RootDatabase,
+    sema: &Semantics<RootDatabase>,
+    current_crate: Crate,
    path_candidate: &PathImportCandidate,
    mod_path: impl Fn(ItemInNs) -> Option<ModPath> + Copy,
-    items_with_candidate_name: FxHashSet<ItemInNs>,
 ) -> FxHashSet<LocatedImport> {
    let _p = profile::span("import_assets::path_applicable_imports");
-    let (unresolved_first_segment, unresolved_qualifier) = match &path_candidate.qualifier {
+    match &path_candidate.qualifier {
        None => {
-            return items_with_candidate_name
+            items_locator::items_with_name(
-                .into_iter()
+                sema,
-                .filter_map(|item| {
+                current_crate,
-                    let mut mod_path = mod_path(item)?;
+                path_candidate.name.clone(),
-                    if let Some(assoc_item) = item_as_assoc(db, item) {
+                // FIXME: we could look up assoc items by the input and propose those in completion,
-                        mod_path.push_segment(assoc_item.name(db)?);
+                // but that requries more preparation first:
-                    }
+                // * store non-trait assoc items in import_map to fully enable this lookup
-                    Some(LocatedImport::new(mod_path.clone(), item, item, Some(mod_path)))
+                // * ensure that does not degrade the performance (bencmark it)
-                })
+                // * write more logic to check for corresponding trait presence requirement (we're unable to flyimport multiple item right now)
-                .collect();
+                // * improve the associated completion item matching and/or scoring to ensure no noisy completions appear
+                //
+                // see also an ignored test under FIXME comment in the qualify_path.rs module
+                AssocItemSearch::Exclude,
+                Some(DEFAULT_QUERY_SEARCH_LIMIT),
+            )
+            .filter_map(|item| {
+                let mod_path = mod_path(item)?;
+                Some(LocatedImport::new(mod_path.clone(), item, item, Some(mod_path)))
+            })
+            .collect()
        }
-        Some(first_segment_unresolved) => (
+        Some(first_segment_unresolved) => {
-            first_segment_unresolved.fist_segment.to_string(),
+            let unresolved_qualifier =
-            path_to_string_stripping_turbo_fish(&first_segment_unresolved.full_qualifier),
+                path_to_string_stripping_turbo_fish(&first_segment_unresolved.full_qualifier);
-        ),
+            let unresolved_first_segment = first_segment_unresolved.fist_segment.text();
-    };
+            items_locator::items_with_name(
+                sema,
-    items_with_candidate_name
+                current_crate,
-        .into_iter()
+                path_candidate.name.clone(),
-        .filter_map(|item| {
+                AssocItemSearch::Include,
-            import_for_item(db, mod_path, &unresolved_first_segment, &unresolved_qualifier, item)
+                Some(DEFAULT_QUERY_SEARCH_LIMIT),
-        })
+            )
-        .collect()
+            .filter_map(|item| {
+                import_for_item(
+                    sema.db,
+                    mod_path,
+                    unresolved_first_segment,
+                    &unresolved_qualifier,
+                    item,
+                )
+            })
+            .collect()
+        }
+    }
 }
 fn import_for_item(
@@ -438,25 +410,31 @@ fn module_with_segment_name(
 }
 fn trait_applicable_items(
-    db: &RootDatabase,
+    sema: &Semantics<RootDatabase>,
    current_crate: Crate,
    trait_candidate: &TraitImportCandidate,
    trait_assoc_item: bool,
    mod_path: impl Fn(ItemInNs) -> Option<ModPath>,
-    items_with_candidate_name: FxHashSet<ItemInNs>,
 ) -> FxHashSet<LocatedImport> {
    let _p = profile::span("import_assets::trait_applicable_items");
-    let mut required_assoc_items = FxHashSet::default();
-    let trait_candidates = items_with_candidate_name
+    let db = sema.db;
-        .into_iter()
-        .filter_map(|input| item_as_assoc(db, input))
+    let mut required_assoc_items = FxHashSet::default();
-        .filter_map(|assoc| {
+    let trait_candidates = items_locator::items_with_name(
-            let assoc_item_trait = assoc.containing_trait(db)?;
+        sema,
-            required_assoc_items.insert(assoc);
+        current_crate,
-            Some(assoc_item_trait.into())
+        trait_candidate.assoc_item_name.clone(),
-        })
+        AssocItemSearch::AssocItemsOnly,
-        .collect();
+        Some(DEFAULT_QUERY_SEARCH_LIMIT),
+    )
+    .filter_map(|input| item_as_assoc(db, input))
+    .filter_map(|assoc| {
+        let assoc_item_trait = assoc.containing_trait(db)?;
+        required_assoc_items.insert(assoc);
+        Some(assoc_item_trait.into())
+    })
+    .collect();
    let mut located_imports = FxHashSet::default();
@@ -565,10 +543,6 @@ impl ImportCandidate {
    ) -> Option<Self> {
        path_import_candidate(sema, qualifier, NameToImport::Fuzzy(fuzzy_name))
    }
-    fn is_trait_candidate(&self) -> bool {
-        matches!(self, ImportCandidate::TraitAssocItem(_) | ImportCandidate::TraitMethod(_))
-    }
 }
 fn path_import_candidate(
diff --git a/crates/ide_db/src/items_locator.rs b/crates/ide_db/src/items_locator.rs
index 8a7f02935..ef796b6f7 100644
--- a/crates/ide_db/src/items_locator.rs
+++ b/crates/ide_db/src/items_locator.rs
@@ -1,6 +1,7 @@
-//! This module contains an import search functionality that is provided to the assists module.
+//! This module has the functionality to search the project and its dependencies for a certain item,
-//! Later, this should be moved away to a separate crate that is accessible from the assists module.
+//! by its name and a few criteria.
+//! The main reason for this module to exist is the fact that project's items and dependencies' items
+//! are located in different caches, with different APIs.
 use either::Either;
 use hir::{
    import_map::{self, ImportKind},
@@ -10,122 +11,121 @@ use syntax::{ast, AstNode, SyntaxKind::NAME};
 use crate::{
    defs::{Definition, NameClass},
+    helpers::import_assets::NameToImport,
    symbol_index::{self, FileSymbol},
    RootDatabase,
 };
-use rustc_hash::FxHashSet;
-pub(crate) const DEFAULT_QUERY_SEARCH_LIMIT: usize = 40;
-pub fn with_exact_name(
+/// A value to use, when uncertain which limit to pick.
-    sema: &Semantics<'_, RootDatabase>,
+pub const DEFAULT_QUERY_SEARCH_LIMIT: usize = 40;
-    krate: Crate,
-    exact_name: String,
-) -> FxHashSet<ItemInNs> {
-    let _p = profile::span("find_exact_imports");
-    find_items(
-        sema,
-        krate,
-        {
-            let mut local_query = symbol_index::Query::new(exact_name.clone());
-            local_query.exact();
-            local_query.limit(DEFAULT_QUERY_SEARCH_LIMIT);
-            local_query
-        },
-        import_map::Query::new(exact_name)
-            .limit(DEFAULT_QUERY_SEARCH_LIMIT)
-            .name_only()
-            .search_mode(import_map::SearchMode::Equals)
-            .case_sensitive(),
-    )
-}
-#[derive(Debug)]
+/// Three possible ways to search for the name in associated and/or other items.
+#[derive(Debug, Clone, Copy)]
 pub enum AssocItemSearch {
+    /// Search for the name in both associated and other items.
    Include,
+    /// Search for the name in other items only.
    Exclude,
+    /// Search for the name in the associated items only.
    AssocItemsOnly,
 }
-pub fn with_similar_name(
+/// Searches for importable items with the given name in the crate and its dependencies.
-    sema: &Semantics<'_, RootDatabase>,
+pub fn items_with_name<'a>(
+    sema: &'a Semantics<'_, RootDatabase>,
    krate: Crate,
-    fuzzy_search_string: String,
+    name: NameToImport,
    assoc_item_search: AssocItemSearch,
    limit: Option<usize>,
-) -> FxHashSet<ItemInNs> {
+) -> impl Iterator<Item = ItemInNs> + 'a {
-    let _p = profile::span("find_similar_imports");
+    let _p = profile::span("items_with_name").detail(|| {
+        format!(
+            "Name: {}, crate: {:?}, assoc items: {:?}, limit: {:?}",
+            name.text(),
+            assoc_item_search,
+            krate.display_name(sema.db).map(|name| name.to_string()),
+            limit,
+        )
+    });
+    let (mut local_query, mut external_query) = match name {
+        NameToImport::Exact(exact_name) => {
+            let mut local_query = symbol_index::Query::new(exact_name.clone());
+            local_query.exact();
-    let mut external_query = import_map::Query::new(fuzzy_search_string.clone())
+            let external_query = import_map::Query::new(exact_name)
-        .search_mode(import_map::SearchMode::Fuzzy)
+                .name_only()
-        .name_only();
+                .search_mode(import_map::SearchMode::Equals)
+                .case_sensitive();
-    match assoc_item_search {
+            (local_query, external_query)
-        AssocItemSearch::Include => {}
-        AssocItemSearch::Exclude => {
-            external_query = external_query.exclude_import_kind(ImportKind::AssociatedItem);
        }
-        AssocItemSearch::AssocItemsOnly => {
+        NameToImport::Fuzzy(fuzzy_search_string) => {
-            external_query = external_query.assoc_items_only();
+            let mut local_query = symbol_index::Query::new(fuzzy_search_string.clone());
+            let mut external_query = import_map::Query::new(fuzzy_search_string.clone())
+                .search_mode(import_map::SearchMode::Fuzzy)
+                .name_only();
+            match assoc_item_search {
+                AssocItemSearch::Include => {}
+                AssocItemSearch::Exclude => {
+                    external_query = external_query.exclude_import_kind(ImportKind::AssociatedItem);
+                }
+                AssocItemSearch::AssocItemsOnly => {
+                    external_query = external_query.assoc_items_only();
+                }
+            }
+            if fuzzy_search_string.to_lowercase() != fuzzy_search_string {
+                local_query.case_sensitive();
+                external_query = external_query.case_sensitive();
+            }
+            (local_query, external_query)
        }
-    }
+    };
-    let mut local_query = symbol_index::Query::new(fuzzy_search_string);
    if let Some(limit) = limit {
        external_query = external_query.limit(limit);
        local_query.limit(limit);
    }
-    find_items(sema, krate, local_query, external_query)
+    find_items(sema, krate, assoc_item_search, local_query, external_query)
-        .into_iter()
-        .filter(move |&item| match assoc_item_search {
-            AssocItemSearch::Include => true,
-            AssocItemSearch::Exclude => !is_assoc_item(item, sema.db),
-            AssocItemSearch::AssocItemsOnly => is_assoc_item(item, sema.db),
-        })
-        .collect()
 }
-fn is_assoc_item(item: ItemInNs, db: &RootDatabase) -> bool {
+fn find_items<'a>(
-    item.as_module_def_id()
+    sema: &'a Semantics<'_, RootDatabase>,
-        .and_then(|module_def_id| ModuleDef::from(module_def_id).as_assoc_item(db))
-        .is_some()
-}
-fn find_items(
-    sema: &Semantics<'_, RootDatabase>,
    krate: Crate,
+    assoc_item_search: AssocItemSearch,
    local_query: symbol_index::Query,
    external_query: import_map::Query,
-) -> FxHashSet<ItemInNs> {
+) -> impl Iterator<Item = ItemInNs> + 'a {
-    let _p = profile::span("find_similar_imports");
+    let _p = profile::span("find_items");
    let db = sema.db;
-    // Query dependencies first.
+    let external_importables =
-    let mut candidates = krate
+        krate.query_external_importables(db, external_query).map(|external_importable| {
-        .query_external_importables(db, external_query)
+            match external_importable {
-        .map(|external_importable| match external_importable {
+                Either::Left(module_def) => ItemInNs::from(module_def),
-            Either::Left(module_def) => ItemInNs::from(module_def),
+                Either::Right(macro_def) => ItemInNs::from(macro_def),
-            Either::Right(macro_def) => ItemInNs::from(macro_def),
+            }
-        })
+        });
-        .collect::<FxHashSet<_>>();
    // Query the local crate using the symbol index.
-    let local_results = symbol_index::crate_symbols(db, krate.into(), local_query);
+    let local_results = symbol_index::crate_symbols(db, krate.into(), local_query)
+        .into_iter()
-    candidates.extend(
+        .filter_map(move |local_candidate| get_name_definition(sema, &local_candidate))
-        local_results
+        .filter_map(|name_definition_to_import| match name_definition_to_import {
-            .into_iter()
+            Definition::ModuleDef(module_def) => Some(ItemInNs::from(module_def)),
-            .filter_map(|local_candidate| get_name_definition(sema, &local_candidate))
+            Definition::Macro(macro_def) => Some(ItemInNs::from(macro_def)),
-            .filter_map(|name_definition_to_import| match name_definition_to_import {
+            _ => None,
-                Definition::ModuleDef(module_def) => Some(ItemInNs::from(module_def)),
+        });
-                Definition::Macro(macro_def) => Some(ItemInNs::from(macro_def)),
-                _ => None,
+    external_importables.chain(local_results).filter(move |&item| match assoc_item_search {
-            }),
+        AssocItemSearch::Include => true,
-    );
+        AssocItemSearch::Exclude => !is_assoc_item(item, sema.db),
+        AssocItemSearch::AssocItemsOnly => is_assoc_item(item, sema.db),
-    candidates
+    })
 }
 fn get_name_definition(
@@ -144,3 +144,9 @@ fn get_name_definition(
    let name = ast::Name::cast(candidate_name_node)?;
    NameClass::classify(sema, &name)?.defined(sema.db)
 }
+fn is_assoc_item(item: ItemInNs, db: &RootDatabase) -> bool {
+    item.as_module_def_id()
+        .and_then(|module_def_id| ModuleDef::from(module_def_id).as_assoc_item(db))
+        .is_some()
+}
diff --git a/crates/ide_db/src/symbol_index.rs b/crates/ide_db/src/symbol_index.rs
index 9ed9568ce..35e382b5c 100644
--- a/crates/ide_db/src/symbol_index.rs
+++ b/crates/ide_db/src/symbol_index.rs
@@ -52,6 +52,7 @@ pub struct Query {
    only_types: bool,
    libs: bool,
    exact: bool,
+    case_sensitive: bool,
    limit: usize,
 }
@@ -64,6 +65,7 @@ impl Query {
            only_types: false,
            libs: false,
            exact: false,
+            case_sensitive: false,
            limit: usize::max_value(),
        }
    }
@@ -80,6 +82,10 @@ impl Query {
        self.exact = true;
    }
+    pub fn case_sensitive(&mut self) {
+        self.case_sensitive = true;
+    }
    pub fn limit(&mut self, limit: usize) {
        self.limit = limit
    }
@@ -326,8 +332,14 @@ impl Query {
                    if self.only_types && !symbol.kind.is_type() {
                        continue;
                    }
-                    if self.exact && symbol.name != self.query {
+                    if self.exact {
-                        continue;
+                        if symbol.name != self.query {
+                            continue;
+                        }
+                    } else if self.case_sensitive {
+                        if self.query.chars().any(|c| !symbol.name.contains(c)) {
+                            continue;
+                        }
                    }
                    res.push(symbol.clone());
diff --git a/crates/ide_ssr/src/parsing.rs b/crates/ide_ssr/src/parsing.rs
index 5ff25cb6d..5e757e701 100644
--- a/crates/ide_ssr/src/parsing.rs
+++ b/crates/ide_ssr/src/parsing.rs
@@ -67,7 +67,7 @@ impl ParsedRule {
    ) -> Result<Vec<ParsedRule>, SsrError> {
        let raw_pattern = pattern.as_rust_code();
        let raw_template = template.map(|t| t.as_rust_code());
-        let raw_template = raw_template.as_ref().map(|s| s.as_str());
+        let raw_template = raw_template.as_deref();
        let mut builder = RuleBuilder {
            placeholders_by_stand_in: pattern.placeholders_by_stand_in(),
            rules: Vec::new(),
diff --git a/crates/mbe/src/expander/matcher.rs b/crates/mbe/src/expander/matcher.rs
index 1682b21b0..75d2f2eed 100644
--- a/crates/mbe/src/expander/matcher.rs
+++ b/crates/mbe/src/expander/matcher.rs
@@ -304,7 +304,7 @@ impl BindingsBuilder {
        link_nodes: &'a Vec<LinkNode<Rc<BindingKind>>>,
        nodes: &mut Vec<&'a Rc<BindingKind>>,
    ) {
-        link_nodes.into_iter().for_each(|it| match it {
+        link_nodes.iter().for_each(|it| match it {
            LinkNode::Node(it) => nodes.push(it),
            LinkNode::Parent { idx, len } => self.collect_nodes_ref(*idx, *len, nodes),
        });
@@ -713,10 +713,9 @@ fn match_meta_var(kind: &str, input: &mut TtIter) -> ExpandResult<Option<Fragmen
                    .map(|ident| Some(tt::Leaf::from(ident.clone()).into()))
                    .map_err(|()| err!("expected ident")),
                "tt" => input.expect_tt().map(Some).map_err(|()| err!()),
-                "lifetime" => input
+                "lifetime" => {
-                    .expect_lifetime()
+                    input.expect_lifetime().map(Some).map_err(|()| err!("expected lifetime"))
-                    .map(|tt| Some(tt))
+                }
-                    .map_err(|()| err!("expected lifetime")),
                "literal" => {
                    let neg = input.eat_char('-');
                    input
diff --git a/crates/mbe/src/lib.rs b/crates/mbe/src/lib.rs
index 33b85e23d..e74f8cf3f 100644
--- a/crates/mbe/src/lib.rs
+++ b/crates/mbe/src/lib.rs
@@ -356,6 +356,6 @@ impl<T> ExpandResult<T> {
 impl<T: Default> From<Result<T, ExpandError>> for ExpandResult<T> {
    fn from(result: Result<T, ExpandError>) -> Self {
-        result.map_or_else(|e| Self::only_err(e), |it| Self::ok(it))
+        result.map_or_else(Self::only_err, Self::ok)
    }
 }
diff --git a/crates/mbe/src/parser.rs b/crates/mbe/src/parser.rs
index c88387653..61b2a4955 100644
--- a/crates/mbe/src/parser.rs
+++ b/crates/mbe/src/parser.rs
@@ -57,7 +57,7 @@ impl<'a> Iterator for OpDelimitedIter<'a> {
    fn size_hint(&self) -> (usize, Option<usize>) {
        let len = self.inner.len() + if self.delimited.is_some() { 2 } else { 0 };
-        let remain = len.checked_sub(self.idx).unwrap_or(0);
+        let remain = len.saturating_sub(self.idx);
        (remain, Some(remain))
    }
 }
diff --git a/crates/mbe/src/syntax_bridge.rs b/crates/mbe/src/syntax_bridge.rs
index 8bba3d3d5..9d433b3b0 100644
--- a/crates/mbe/src/syntax_bridge.rs
+++ b/crates/mbe/src/syntax_bridge.rs
@@ -362,7 +362,7 @@ trait TokenConvertor {
            if let Some((kind, closed)) = delim {
                let mut subtree = tt::Subtree::default();
                let (id, idx) = self.id_alloc().open_delim(range);
-                subtree.delimiter = Some(tt::Delimiter { kind, id });
+                subtree.delimiter = Some(tt::Delimiter { id, kind });
                while self.peek().map(|it| it.kind() != closed).unwrap_or(false) {
                    self.collect_leaf(&mut subtree.token_trees);
diff --git a/crates/mbe/src/tests/expand.rs b/crates/mbe/src/tests/expand.rs
index 2cce62781..8951f3813 100644
--- a/crates/mbe/src/tests/expand.rs
+++ b/crates/mbe/src/tests/expand.rs
@@ -1225,8 +1225,7 @@ macro_rules! m {
    )
    .expand_statements(r#"m!(C("0"))"#)
    .descendants()
-    .find(|token| token.kind() == ERROR)
+    .any(|token| token.kind() == ERROR));
-    .is_some());
 }
 #[test]
diff --git a/crates/project_model/src/build_data.rs b/crates/project_model/src/build_data.rs
index 728a258ea..f7050be4e 100644
--- a/crates/project_model/src/build_data.rs
+++ b/crates/project_model/src/build_data.rs
@@ -137,60 +137,53 @@ fn collect_from_workspace(
    let stdout = BufReader::new(child_stdout);
    let mut res = BuildDataMap::default();
-    for message in cargo_metadata::Message::parse_stream(stdout) {
+    for message in cargo_metadata::Message::parse_stream(stdout).flatten() {
-        if let Ok(message) = message {
+        match message {
-            match message {
+            Message::BuildScriptExecuted(BuildScript {
-                Message::BuildScriptExecuted(BuildScript {
+                package_id, out_dir, cfgs, env, ..
-                    package_id,
+            }) => {
-                    out_dir,
+                let cfgs = {
-                    cfgs,
+                    let mut acc = Vec::new();
-                    env,
+                    for cfg in cfgs {
-                    ..
+                        match cfg.parse::<CfgFlag>() {
-                }) => {
+                            Ok(it) => acc.push(it),
-                    let cfgs = {
+                            Err(err) => {
-                        let mut acc = Vec::new();
+                                anyhow::bail!("invalid cfg from cargo-metadata: {}", err)
-                        for cfg in cfgs {
+                            }
-                            match cfg.parse::<CfgFlag>() {
+                        };
-                                Ok(it) => acc.push(it),
-                                Err(err) => {
-                                    anyhow::bail!("invalid cfg from cargo-metadata: {}", err)
-                                }
-                            };
-                        }
-                        acc
-                    };
-                    let res = res.entry(package_id.repr.clone()).or_default();
-                    // cargo_metadata crate returns default (empty) path for
-                    // older cargos, which is not absolute, so work around that.
-                    if !out_dir.as_str().is_empty() {
-                        let out_dir = AbsPathBuf::assert(PathBuf::from(out_dir.into_os_string()));
-                        res.out_dir = Some(out_dir);
-                        res.cfgs = cfgs;
                    }
+                    acc
-                    res.envs = env;
+                };
+                let res = res.entry(package_id.repr.clone()).or_default();
+                // cargo_metadata crate returns default (empty) path for
+                // older cargos, which is not absolute, so work around that.
+                if !out_dir.as_str().is_empty() {
+                    let out_dir = AbsPathBuf::assert(PathBuf::from(out_dir.into_os_string()));
+                    res.out_dir = Some(out_dir);
+                    res.cfgs = cfgs;
                }
-                Message::CompilerArtifact(message) => {
-                    progress(format!("metadata {}", message.target.name));
+                res.envs = env;
+            }
-                    if message.target.kind.contains(&"proc-macro".to_string()) {
+            Message::CompilerArtifact(message) => {
-                        let package_id = message.package_id;
+                progress(format!("metadata {}", message.target.name));
-                        // Skip rmeta file
-                        if let Some(filename) = message.filenames.iter().find(|name| is_dylib(name))
+                if message.target.kind.contains(&"proc-macro".to_string()) {
-                        {
+                    let package_id = message.package_id;
-                            let filename = AbsPathBuf::assert(PathBuf::from(&filename));
+                    // Skip rmeta file
-                            let res = res.entry(package_id.repr.clone()).or_default();
+                    if let Some(filename) = message.filenames.iter().find(|name| is_dylib(name)) {
-                            res.proc_macro_dylib_path = Some(filename);
+                        let filename = AbsPathBuf::assert(PathBuf::from(&filename));
-                        }
+                        let res = res.entry(package_id.repr.clone()).or_default();
+                        res.proc_macro_dylib_path = Some(filename);
                    }
                }
-                Message::CompilerMessage(message) => {
-                    progress(message.target.name.clone());
-                }
-                Message::BuildFinished(_) => {}
-                Message::TextLine(_) => {}
-                _ => {}
            }
+            Message::CompilerMessage(message) => {
+                progress(message.target.name.clone());
+            }
+            Message::BuildFinished(_) => {}
+            Message::TextLine(_) => {}
+            _ => {}
        }
    }
diff --git a/crates/rust-analyzer/src/caps.rs b/crates/rust-analyzer/src/caps.rs
index aa48c455c..7a5bcb8c7 100644
--- a/crates/rust-analyzer/src/caps.rs
+++ b/crates/rust-analyzer/src/caps.rs
@@ -33,7 +33,7 @@ pub fn server_capabilities(client_caps: &ClientCapabilities) -> ServerCapabiliti
        hover_provider: Some(HoverProviderCapability::Simple(true)),
        completion_provider: Some(CompletionOptions {
            resolve_provider: completions_resolve_provider(client_caps),
-            trigger_characters: Some(vec![":".to_string(), ".".to_string()]),
+            trigger_characters: Some(vec![":".to_string(), ".".to_string(), "'".to_string()]),
            all_commit_characters: None,
            completion_item: None,
            work_done_progress_options: WorkDoneProgressOptions { work_done_progress: None },
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 984790d35..c63a0eaea 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -242,11 +242,8 @@ impl GlobalState {
                                }
                                BuildDataProgress::End(collector) => {
                                    self.fetch_build_data_completed();
-                                    let workspaces = (*self.workspaces)
+                                    let workspaces =
-                                        .clone()
+                                        (*self.workspaces).clone().into_iter().map(Ok).collect();
-                                        .into_iter()
-                                        .map(|it| Ok(it))
-                                        .collect();
                                    self.switch_workspaces(workspaces, Some(collector));
                                    (Some(Progress::End), None)
                                }
diff --git a/crates/rust-analyzer/src/reload.rs b/crates/rust-analyzer/src/reload.rs
index aa8504c3d..76fdbcddd 100644
--- a/crates/rust-analyzer/src/reload.rs
+++ b/crates/rust-analyzer/src/reload.rs
@@ -237,7 +237,7 @@ impl GlobalState {
            None => None,
        };
-        if &*self.workspaces == &workspaces && self.workspace_build_data == workspace_build_data {
+        if *self.workspaces == workspaces && self.workspace_build_data == workspace_build_data {
            return;
        }
diff --git a/crates/rust-analyzer/tests/rust-analyzer/support.rs b/crates/rust-analyzer/tests/rust-analyzer/support.rs
index cd0c91481..95bf26f01 100644
--- a/crates/rust-analyzer/tests/rust-analyzer/support.rs
+++ b/crates/rust-analyzer/tests/rust-analyzer/support.rs
@@ -54,7 +54,7 @@ impl<'a> Project<'a> {
    }
    pub(crate) fn server(self) -> Server {
-        let tmp_dir = self.tmp_dir.unwrap_or_else(|| TestDir::new());
+        let tmp_dir = self.tmp_dir.unwrap_or_else(TestDir::new);
        static INIT: Once = Once::new();
        INIT.call_once(|| {
            env_logger::builder().is_test(true).parse_env("RA_LOG").try_init().unwrap();
diff --git a/crates/syntax/src/algo.rs b/crates/syntax/src/algo.rs
index 82ebf9037..a153a9e1c 100644
--- a/crates/syntax/src/algo.rs
+++ b/crates/syntax/src/algo.rs
@@ -567,7 +567,7 @@ impl<'a> SyntaxRewriter<'a> {
 fn element_to_green(element: SyntaxElement) -> NodeOrToken<rowan::GreenNode, rowan::GreenToken> {
    match element {
-        NodeOrToken::Node(it) => NodeOrToken::Node(it.green().to_owned()),
+        NodeOrToken::Node(it) => NodeOrToken::Node(it.green()),
        NodeOrToken::Token(it) => NodeOrToken::Token(it.green().to_owned()),
    }
 }
@@ -625,7 +625,7 @@ fn position_of_child(parent: &SyntaxNode, child: SyntaxElement) -> usize {
 fn to_green_element(element: SyntaxElement) -> NodeOrToken<rowan::GreenNode, rowan::GreenToken> {
    match element {
-        NodeOrToken::Node(it) => it.green().to_owned().into(),
+        NodeOrToken::Node(it) => it.green().into(),
        NodeOrToken::Token(it) => it.green().to_owned().into(),
    }
 }
diff --git a/crates/syntax/src/ast/edit.rs b/crates/syntax/src/ast/edit.rs
index 64fac13a7..347862b8a 100644
--- a/crates/syntax/src/ast/edit.rs
+++ b/crates/syntax/src/ast/edit.rs
@@ -333,8 +333,7 @@ impl ast::Use {
            .and_then(ast::Whitespace::cast);
        if let Some(next_ws) = next_ws {
            let ws_text = next_ws.syntax().text();
-            if ws_text.starts_with('\n') {
+            if let Some(rest) = ws_text.strip_prefix('\n') {
-                let rest = &ws_text[1..];
                if rest.is_empty() {
                    res.delete(next_ws.syntax())
                } else {
@@ -462,8 +461,7 @@ impl ast::MatchArmList {
        let end = if let Some(comma) = start
            .siblings_with_tokens(Direction::Next)
            .skip(1)
-            .skip_while(|it| it.kind().is_trivia())
+            .find(|it| !it.kind().is_trivia())
-            .next()
            .filter(|it| it.kind() == T![,])
        {
            comma
@@ -597,7 +595,7 @@ impl IndentLevel {
    pub fn from_node(node: &SyntaxNode) -> IndentLevel {
        match node.first_token() {
            Some(it) => Self::from_token(&it),
-            None => return IndentLevel(0),
+            None => IndentLevel(0),
        }
    }
diff --git a/crates/syntax/src/ast/expr_ext.rs b/crates/syntax/src/ast/expr_ext.rs
index 636ce166d..6317d84ba 100644
--- a/crates/syntax/src/ast/expr_ext.rs
+++ b/crates/syntax/src/ast/expr_ext.rs
@@ -11,16 +11,16 @@ impl ast::AttrsOwner for ast::Expr {}
 impl ast::Expr {
    pub fn is_block_like(&self) -> bool {
-        match self {
+        matches!(
+            self,
            ast::Expr::IfExpr(_)
-            | ast::Expr::LoopExpr(_)
+                | ast::Expr::LoopExpr(_)
-            | ast::Expr::ForExpr(_)
+                | ast::Expr::ForExpr(_)
-            | ast::Expr::WhileExpr(_)
+                | ast::Expr::WhileExpr(_)
-            | ast::Expr::BlockExpr(_)
+                | ast::Expr::BlockExpr(_)
-            | ast::Expr::MatchExpr(_)
+                | ast::Expr::MatchExpr(_)
-            | ast::Expr::EffectExpr(_) => true,
+                | ast::Expr::EffectExpr(_)
-            _ => false,
+        )
-        }
    }
    pub fn name_ref(&self) -> Option<ast::NameRef> {
@@ -151,20 +151,20 @@ pub enum BinOp {
 impl BinOp {
    pub fn is_assignment(self) -> bool {
-        match self {
+        matches!(
+            self,
            BinOp::Assignment
-            | BinOp::AddAssign
+                | BinOp::AddAssign
-            | BinOp::DivAssign
+                | BinOp::DivAssign
-            | BinOp::MulAssign
+                | BinOp::MulAssign
-            | BinOp::RemAssign
+                | BinOp::RemAssign
-            | BinOp::ShrAssign
+                | BinOp::ShrAssign
-            | BinOp::ShlAssign
+                | BinOp::ShlAssign
-            | BinOp::SubAssign
+                | BinOp::SubAssign
-            | BinOp::BitOrAssign
+                | BinOp::BitOrAssign
-            | BinOp::BitAndAssign
+                | BinOp::BitAndAssign
-            | BinOp::BitXorAssign => true,
+                | BinOp::BitXorAssign
-            _ => false,
+        )
-        }
    }
 }
diff --git a/crates/syntax/src/ast/make.rs b/crates/syntax/src/ast/make.rs
index 810c8d4c8..7049affd9 100644
--- a/crates/syntax/src/ast/make.rs
+++ b/crates/syntax/src/ast/make.rs
@@ -532,7 +532,7 @@ fn ast_from_text<N: AstNode>(text: &str) -> N {
 }
 fn unroot(n: SyntaxNode) -> SyntaxNode {
-    SyntaxNode::new_root(n.green().to_owned())
+    SyntaxNode::new_root(n.green())
 }
 pub mod tokens {
diff --git a/crates/syntax/src/ast/node_ext.rs b/crates/syntax/src/ast/node_ext.rs
index 42a7b9c2a..bdf907a21 100644
--- a/crates/syntax/src/ast/node_ext.rs
+++ b/crates/syntax/src/ast/node_ext.rs
@@ -58,10 +58,7 @@ impl From<ast::MacroDef> for Macro {
 impl AstNode for Macro {
    fn can_cast(kind: SyntaxKind) -> bool {
-        match kind {
+        matches!(kind, SyntaxKind::MACRO_RULES | SyntaxKind::MACRO_DEF)
-            SyntaxKind::MACRO_RULES | SyntaxKind::MACRO_DEF => true,
-            _ => false,
-        }
    }
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        let res = match syntax.kind() {
@@ -462,10 +459,8 @@ impl ast::FieldExpr {
    pub fn field_access(&self) -> Option<FieldKind> {
        if let Some(nr) = self.name_ref() {
            Some(FieldKind::Name(nr))
-        } else if let Some(tok) = self.index_token() {
-            Some(FieldKind::Index(tok))
        } else {
-            None
+            self.index_token().map(FieldKind::Index)
        }
    }
 }
@@ -482,16 +477,10 @@ impl ast::SlicePat {
        let prefix = args
            .peeking_take_while(|p| match p {
                ast::Pat::RestPat(_) => false,
-                ast::Pat::IdentPat(bp) => match bp.pat() {
+                ast::Pat::IdentPat(bp) => !matches!(bp.pat(), Some(ast::Pat::RestPat(_))),
-                    Some(ast::Pat::RestPat(_)) => false,
-                    _ => true,
-                },
                ast::Pat::RefPat(rp) => match rp.pat() {
                    Some(ast::Pat::RestPat(_)) => false,
-                    Some(ast::Pat::IdentPat(bp)) => match bp.pat() {
+                    Some(ast::Pat::IdentPat(bp)) => !matches!(bp.pat(), Some(ast::Pat::RestPat(_))),
-                        Some(ast::Pat::RestPat(_)) => false,
-                        _ => true,
-                    },
                    _ => true,
                },
                _ => true,
diff --git a/crates/syntax/src/ast/token_ext.rs b/crates/syntax/src/ast/token_ext.rs
index 6c242d126..090282d28 100644
--- a/crates/syntax/src/ast/token_ext.rs
+++ b/crates/syntax/src/ast/token_ext.rs
@@ -494,9 +494,8 @@ pub trait HasFormatSpecifier: AstToken {
                }
                _ => {
                    while let Some((_, Ok(next_char))) = chars.peek() {
-                        match next_char {
+                        if next_char == &'{' {
-                            '{' => break,
+                            break;
-                            _ => {}
                        }
                        chars.next();
                    }
diff --git a/crates/syntax/src/fuzz.rs b/crates/syntax/src/fuzz.rs
index fbb97aa27..aa84239d2 100644
--- a/crates/syntax/src/fuzz.rs
+++ b/crates/syntax/src/fuzz.rs
@@ -43,7 +43,7 @@ impl CheckReparse {
            TextRange::at(delete_start.try_into().unwrap(), delete_len.try_into().unwrap());
        let edited_text =
            format!("{}{}{}", &text[..delete_start], &insert, &text[delete_start + delete_len..]);
-        let edit = Indel { delete, insert };
+        let edit = Indel { insert, delete };
        Some(CheckReparse { text, edit, edited_text })
    }
diff --git a/crates/syntax/src/validation.rs b/crates/syntax/src/validation.rs
index 3e216fb70..bbe802174 100644
--- a/crates/syntax/src/validation.rs
+++ b/crates/syntax/src/validation.rs
@@ -297,7 +297,7 @@ fn validate_path_keywords(segment: ast::PathSegment, errors: &mut Vec<SyntaxErro
                }
            };
        }
-        return None;
+        None
    }
    fn all_supers(path: &ast::Path) -> bool {
@@ -314,7 +314,7 @@ fn validate_path_keywords(segment: ast::PathSegment, errors: &mut Vec<SyntaxErro
            return all_supers(subpath);
        }
-        return true;
+        true
    }
 }
diff --git a/crates/tt/src/lib.rs b/crates/tt/src/lib.rs
index 9d9a01e30..bed44d600 100644
--- a/crates/tt/src/lib.rs
+++ b/crates/tt/src/lib.rs
@@ -239,9 +239,8 @@ impl Subtree {
        let mut res = String::new();
        res.push_str(delim.0);
-        let mut iter = self.token_trees.iter();
        let mut last = None;
-        while let Some(child) = iter.next() {
+        for child in &self.token_trees {
            let s = match child {
                TokenTree::Leaf(it) => {
                    let s = match it {
diff --git a/xtask/src/codegen/gen_assists_docs.rs b/xtask/src/codegen/gen_assists_docs.rs
index 158680993..c91716409 100644
--- a/xtask/src/codegen/gen_assists_docs.rs
+++ b/xtask/src/codegen/gen_assists_docs.rs
@@ -154,8 +154,8 @@ fn hide_hash_comments(text: &str) -> String {
 fn reveal_hash_comments(text: &str) -> String {
    text.split('\n') // want final newline
        .map(|it| {
-            if it.starts_with("# ") {
+            if let Some(stripped) = it.strip_prefix("# ") {
-                &it[2..]
+                stripped
            } else if it == "#" {
                ""
            } else {
diff --git a/xtask/src/codegen/gen_parser_tests.rs b/xtask/src/codegen/gen_parser_tests.rs
index 096590653..2fecb9b5b 100644
--- a/xtask/src/codegen/gen_parser_tests.rs
+++ b/xtask/src/codegen/gen_parser_tests.rs
@@ -60,12 +60,10 @@ fn collect_tests(s: &str) -> Vec<Test> {
    let mut res = Vec::new();
    for comment_block in extract_comment_blocks(s) {
        let first_line = &comment_block[0];
-        let (name, ok) = if first_line.starts_with("test ") {
+        let (name, ok) = if let Some(name) = first_line.strip_prefix("test ") {
-            let name = first_line["test ".len()..].to_string();
+            (name.to_string(), true)
-            (name, true)
+        } else if let Some(name) = first_line.strip_prefix("test_err ") {
-        } else if first_line.starts_with("test_err ") {
+            (name.to_string(), false)
-            let name = first_line["test_err ".len()..].to_string();
-            (name, false)
        } else {
            continue;
        };
diff --git a/xtask/src/codegen/gen_syntax.rs b/xtask/src/codegen/gen_syntax.rs
index 80f26e8f5..ba4b24848 100644
--- a/xtask/src/codegen/gen_syntax.rs
+++ b/xtask/src/codegen/gen_syntax.rs
@@ -707,7 +707,7 @@ fn extract_struct_trait(node: &mut AstNodeSrc, trait_name: &str, methods: &[&str
    let mut to_remove = Vec::new();
    for (i, field) in node.fields.iter().enumerate() {
        let method_name = field.method_name().to_string();
-        if methods.iter().any(|&it| it == &method_name) {
+        if methods.iter().any(|&it| it == method_name) {
            to_remove.push(i);
        }
    }
diff --git a/xtask/src/main.rs b/xtask/src/main.rs
index 915aae71a..960927fc0 100644
--- a/xtask/src/main.rs
+++ b/xtask/src/main.rs
@@ -37,7 +37,7 @@ fn main() -> Result<()> {
    match flags.subcommand {
        flags::XtaskCmd::Help(_) => {
            println!("{}", flags::Xtask::HELP);
-            return Ok(());
+            Ok(())
        }
        flags::XtaskCmd::Install(cmd) => cmd.run(),
        flags::XtaskCmd::FuzzTests(_) => run_fuzzer(),
diff --git a/xtask/src/metrics.rs b/xtask/src/metrics.rs
index 97395738b..b0b76b8aa 100644
--- a/xtask/src/metrics.rs
+++ b/xtask/src/metrics.rs
@@ -167,7 +167,7 @@ impl Host {
        return Ok(Host { os, cpu, mem });
-        fn read_field<'a>(path: &str, field: &str) -> Result<String> {
+        fn read_field(path: &str, field: &str) -> Result<String> {
            let text = read_file(path)?;
            let line = text
diff --git a/xtask/src/tidy.rs b/xtask/src/tidy.rs
index 1352d1218..50d9efccd 100644
--- a/xtask/src/tidy.rs
+++ b/xtask/src/tidy.rs
@@ -193,7 +193,7 @@ https://github.blog/2015-06-08-how-to-undo-almost-anything-with-git/#redo-after-
    }
 }
-fn deny_clippy(path: &PathBuf, text: &String) {
+fn deny_clippy(path: &Path, text: &str) {
    let ignore = &[
        // The documentation in string literals may contain anything for its own purposes
        "ide_completion/src/generated_lint_completions.rs",