35 files changed, 360 insertions, 142 deletions
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 05a60e158..4ee08ef21 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -51,7 +51,7 @@ use hir_def::{
 };
 use hir_expand::{diagnostics::DiagnosticSink, name::name, MacroDefKind};
 use hir_ty::{
-    autoderef,
+    autoderef, could_unify,
    method_resolution::{self, TyFingerprint},
    primitive::UintTy,
    to_assoc_type_id,
@@ -2154,6 +2154,10 @@ impl Type {
        walk_type(db, self, &mut cb);
    }
+    pub fn could_unify_with(&self, other: &Type) -> bool {
+        could_unify(&self.ty, &other.ty)
+    }
 }
 // FIXME: closures
diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index 1198e3f0b..3ff135f41 100644
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs
@@ -445,7 +445,7 @@ impl<'db> SemanticsImpl<'db> {
                }
            };
            gpl.lifetime_params()
-                .find(|tp| tp.lifetime().as_ref().map(|lt| lt.text()) == Some(text))
+                .find(|tp| tp.lifetime().as_ref().map(|lt| lt.text()).as_ref() == Some(&text))
        })?;
        let src = self.find_file(lifetime_param.syntax().clone()).with_value(lifetime_param);
        ToDef::to_def(self, src)
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index 19f5065d1..229e81dd4 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -74,6 +74,7 @@ pub(super) fn lower(
            _c: Count::new(),
        },
        expander,
+        statements_in_scope: Vec::new(),
    }
    .collect(params, body)
 }
@@ -83,6 +84,7 @@ struct ExprCollector<'a> {
    expander: Expander,
    body: Body,
    source_map: BodySourceMap,
+    statements_in_scope: Vec<Statement>,
 }
 impl ExprCollector<'_> {
@@ -533,15 +535,13 @@ impl ExprCollector<'_> {
                ids[0]
            }
            ast::Expr::MacroStmts(e) => {
-                // FIXME:  these statements should be held by some hir containter
+                e.statements().for_each(|s| self.collect_stmt(s));
-                for stmt in e.statements() {
+                let tail = e
-                    self.collect_stmt(stmt);
+                    .expr()
-                }
+                    .map(|e| self.collect_expr(e))
-                if let Some(expr) = e.expr() {
+                    .unwrap_or_else(|| self.alloc_expr(Expr::Missing, syntax_ptr.clone()));
-                    self.collect_expr(expr)
-                } else {
+                self.alloc_expr(Expr::MacroStmts { tail }, syntax_ptr)
-                    self.alloc_expr(Expr::Missing, syntax_ptr)
-                }
            }
        })
    }
@@ -618,58 +618,54 @@ impl ExprCollector<'_> {
        }
    }
-    fn collect_stmt(&mut self, s: ast::Stmt) -> Option<Vec<Statement>> {
+    fn collect_stmt(&mut self, s: ast::Stmt) {
-        let stmt = match s {
+        match s {
            ast::Stmt::LetStmt(stmt) => {
-                self.check_cfg(&stmt)?;
+                if self.check_cfg(&stmt).is_none() {
+                    return;
+                }
                let pat = self.collect_pat_opt(stmt.pat());
                let type_ref = stmt.ty().map(|it| TypeRef::from_ast(&self.ctx(), it));
                let initializer = stmt.initializer().map(|e| self.collect_expr(e));
-                vec![Statement::Let { pat, type_ref, initializer }]
+                self.statements_in_scope.push(Statement::Let { pat, type_ref, initializer });
            }
            ast::Stmt::ExprStmt(stmt) => {
-                self.check_cfg(&stmt)?;
+                if self.check_cfg(&stmt).is_none() {
+                    return;
+                }
                // Note that macro could be expended to multiple statements
                if let Some(ast::Expr::MacroCall(m)) = stmt.expr() {
                    let syntax_ptr = AstPtr::new(&stmt.expr().unwrap());
-                    let mut stmts = vec![];
                    self.collect_macro_call(m, syntax_ptr.clone(), false, |this, expansion| {
                        match expansion {
                            Some(expansion) => {
                                let statements: ast::MacroStmts = expansion;
-                                statements.statements().for_each(|stmt| {
+                                statements.statements().for_each(|stmt| this.collect_stmt(stmt));
-                                    if let Some(mut r) = this.collect_stmt(stmt) {
-                                        stmts.append(&mut r);
-                                    }
-                                });
                                if let Some(expr) = statements.expr() {
-                                    stmts.push(Statement::Expr(this.collect_expr(expr)));
+                                    let expr = this.collect_expr(expr);
+                                    this.statements_in_scope.push(Statement::Expr(expr));
                                }
                            }
                            None => {
-                                stmts.push(Statement::Expr(
+                                let expr = this.alloc_expr(Expr::Missing, syntax_ptr.clone());
-                                    this.alloc_expr(Expr::Missing, syntax_ptr.clone()),
+                                this.statements_in_scope.push(Statement::Expr(expr));
-                                ));
                            }
                        }
                    });
-                    stmts
                } else {
-                    vec![Statement::Expr(self.collect_expr_opt(stmt.expr()))]
+                    let expr = self.collect_expr_opt(stmt.expr());
+                    self.statements_in_scope.push(Statement::Expr(expr));
                }
            }
            ast::Stmt::Item(item) => {
-                self.check_cfg(&item)?;
+                if self.check_cfg(&item).is_none() {
+                    return;
-                return None;
+                }
            }
-        };
+        }
-        Some(stmt)
    }
    fn collect_block(&mut self, block: ast::BlockExpr) -> ExprId {
@@ -685,10 +681,12 @@ impl ExprCollector<'_> {
        let module = if has_def_map { def_map.root() } else { self.expander.module };
        let prev_def_map = mem::replace(&mut self.expander.def_map, def_map);
        let prev_local_module = mem::replace(&mut self.expander.module, module);
+        let prev_statements = std::mem::take(&mut self.statements_in_scope);
+        block.statements().for_each(|s| self.collect_stmt(s));
-        let statements =
-            block.statements().filter_map(|s| self.collect_stmt(s)).flatten().collect();
        let tail = block.tail_expr().map(|e| self.collect_expr(e));
+        let statements = std::mem::replace(&mut self.statements_in_scope, prev_statements);
        let syntax_node_ptr = AstPtr::new(&block.into());
        let expr_id = self.alloc_expr(
            Expr::Block { id: block_id, statements, tail, label: None },
diff --git a/crates/hir_def/src/expr.rs b/crates/hir_def/src/expr.rs
index 24be93773..6c7376fad 100644
--- a/crates/hir_def/src/expr.rs
+++ b/crates/hir_def/src/expr.rs
@@ -171,6 +171,9 @@ pub enum Expr {
    Unsafe {
        body: ExprId,
    },
+    MacroStmts {
+        tail: ExprId,
+    },
    Array(Array),
    Literal(Literal),
 }
@@ -357,6 +360,7 @@ impl Expr {
                    f(*repeat)
                }
            },
+            Expr::MacroStmts { tail } => f(*tail),
            Expr::Literal(_) => {}
        }
    }
diff --git a/crates/hir_def/src/item_tree.rs b/crates/hir_def/src/item_tree.rs
index ae2475b4e..ca0048b16 100644
--- a/crates/hir_def/src/item_tree.rs
+++ b/crates/hir_def/src/item_tree.rs
@@ -110,15 +110,6 @@ impl ItemTree {
                    // still need to collect inner items.
                    ctx.lower_inner_items(e.syntax())
                },
-                ast::ExprStmt(stmt) => {
-                    // Macros can expand to stmt. We return an empty item tree in this case, but
-                    // still need to collect inner items.
-                    ctx.lower_inner_items(stmt.syntax())
-                },
-                ast::Item(item) => {
-                    // Macros can expand to stmt and other item, and we add it as top level item
-                    ctx.lower_single_item(item)
-                },
                _ => {
                    panic!("cannot create item tree from {:?} {}", syntax, syntax);
                },
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index d3fe1ce1e..3f558edd8 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -87,14 +87,6 @@ impl Ctx {
        self.tree
    }
-    pub(super) fn lower_single_item(mut self, item: ast::Item) -> ItemTree {
-        self.tree.top_level = self
-            .lower_mod_item(&item, false)
-            .map(|item| item.0)
-            .unwrap_or_else(|| Default::default());
-        self.tree
-    }
    pub(super) fn lower_inner_items(mut self, within: &SyntaxNode) -> ItemTree {
        self.collect_inner_items(within);
        self.tree
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index fc73e435b..d672f6723 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -5,7 +5,13 @@ use std::sync::Arc;
 use base_db::{salsa, SourceDatabase};
 use mbe::{ExpandError, ExpandResult, MacroRules};
 use parser::FragmentKind;
-use syntax::{algo::diff, ast::NameOwner, AstNode, GreenNode, Parse, SyntaxKind::*, SyntaxNode};
+use syntax::{
+    algo::diff,
+    ast::{MacroStmts, NameOwner},
+    AstNode, GreenNode, Parse,
+    SyntaxKind::*,
+    SyntaxNode,
+};
 use crate::{
    ast_id_map::AstIdMap, hygiene::HygieneFrame, BuiltinDeriveExpander, BuiltinFnLikeExpander,
@@ -340,13 +346,19 @@ fn parse_macro_with_arg(
        None => return ExpandResult { value: None, err: result.err },
    };
-    log::debug!("expanded = {}", tt.as_debug_string());
    let fragment_kind = to_fragment_kind(db, macro_call_id);
+    log::debug!("expanded = {}", tt.as_debug_string());
+    log::debug!("kind = {:?}", fragment_kind);
    let (parse, rev_token_map) = match mbe::token_tree_to_syntax_node(&tt, fragment_kind) {
        Ok(it) => it,
        Err(err) => {
+            log::debug!(
+                "failed to parse expanstion to {:?} = {}",
+                fragment_kind,
+                tt.as_debug_string()
+            );
            return ExpandResult::only_err(err);
        }
    };
@@ -362,15 +374,34 @@ fn parse_macro_with_arg(
                    return ExpandResult::only_err(err);
                }
            };
+            if is_self_replicating(&node, &call_node.value) {
-            if !diff(&node, &call_node.value).is_empty() {
-                ExpandResult { value: Some((parse, Arc::new(rev_token_map))), err: Some(err) }
-            } else {
                return ExpandResult::only_err(err);
+            } else {
+                ExpandResult { value: Some((parse, Arc::new(rev_token_map))), err: Some(err) }
+            }
+        }
+        None => {
+            log::debug!("parse = {:?}", parse.syntax_node().kind());
+            ExpandResult { value: Some((parse, Arc::new(rev_token_map))), err: None }
+        }
+    }
+}
+fn is_self_replicating(from: &SyntaxNode, to: &SyntaxNode) -> bool {
+    if diff(from, to).is_empty() {
+        return true;
+    }
+    if let Some(stmts) = MacroStmts::cast(from.clone()) {
+        if stmts.statements().any(|stmt| diff(stmt.syntax(), to).is_empty()) {
+            return true;
+        }
+        if let Some(expr) = stmts.expr() {
+            if diff(expr.syntax(), to).is_empty() {
+                return true;
            }
        }
-        None => ExpandResult { value: Some((parse, Arc::new(rev_token_map))), err: None },
    }
+    false
 }
 fn hygiene_frame(db: &dyn AstDatabase, file_id: HirFileId) -> Arc<HygieneFrame> {
@@ -390,21 +421,15 @@ fn to_fragment_kind(db: &dyn AstDatabase, id: MacroCallId) -> FragmentKind {
    let parent = match syn.parent() {
        Some(it) => it,
-        None => {
+        None => return FragmentKind::Statements,
-            // FIXME:
-            // If it is root, which means the parent HirFile
-            // MacroKindFile must be non-items
-            // return expr now.
-            return FragmentKind::Expr;
-        }
    };
    match parent.kind() {
        MACRO_ITEMS | SOURCE_FILE => FragmentKind::Items,
-        MACRO_STMTS => FragmentKind::Statement,
+        MACRO_STMTS => FragmentKind::Statements,
        ITEM_LIST => FragmentKind::Items,
        LET_STMT => {
-            // FIXME: Handle Pattern
+            // FIXME: Handle LHS Pattern
            FragmentKind::Expr
        }
        EXPR_STMT => FragmentKind::Statements,
diff --git a/crates/hir_expand/src/name.rs b/crates/hir_expand/src/name.rs
index 0aeea48d5..cd691b1d2 100644
--- a/crates/hir_expand/src/name.rs
+++ b/crates/hir_expand/src/name.rs
@@ -75,14 +75,14 @@ impl AsName for ast::NameRef {
    fn as_name(&self) -> Name {
        match self.as_tuple_field() {
            Some(idx) => Name::new_tuple_field(idx),
-            None => Name::resolve(self.text()),
+            None => Name::resolve(&self.text()),
        }
    }
 }
 impl AsName for ast::Name {
    fn as_name(&self) -> Name {
-        Name::resolve(self.text())
+        Name::resolve(&self.text())
    }
 }
diff --git a/crates/hir_ty/src/infer.rs b/crates/hir_ty/src/infer.rs
index 8f9cf7480..e4407ff50 100644
--- a/crates/hir_ty/src/infer.rs
+++ b/crates/hir_ty/src/infer.rs
@@ -45,6 +45,11 @@ use crate::{
    to_assoc_type_id, to_chalk_trait_id, AliasEq, AliasTy, Interner, TyKind,
 };
+// This lint has a false positive here. See the link below for details.
+//
+// https://github.com/rust-lang/rust/issues/57411
+#[allow(unreachable_pub)]
+pub use unify::could_unify;
 pub(crate) use unify::unify;
 mod unify;
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index 3f3187ea2..e6ede05ca 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -767,6 +767,7 @@ impl<'a> InferenceContext<'a> {
                    None => self.table.new_float_var(),
                },
            },
+            Expr::MacroStmts { tail } => self.infer_expr(*tail, expected),
        };
        // use a new type variable if we got unknown here
        let ty = self.insert_type_vars_shallow(ty);
diff --git a/crates/hir_ty/src/infer/unify.rs b/crates/hir_ty/src/infer/unify.rs
index 75250a369..6e7b0f5a6 100644
--- a/crates/hir_ty/src/infer/unify.rs
+++ b/crates/hir_ty/src/infer/unify.rs
@@ -157,6 +157,10 @@ impl<T> Canonicalized<T> {
    }
 }
+pub fn could_unify(t1: &Ty, t2: &Ty) -> bool {
+    InferenceTable::new().unify(t1, t2)
+}
 pub(crate) fn unify(tys: &Canonical<(Ty, Ty)>) -> Option<Substitution> {
    let mut table = InferenceTable::new();
    let vars = Substitution(
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index 69265286f..6f9c698e6 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -41,7 +41,7 @@ use crate::{
 };
 pub use autoderef::autoderef;
-pub use infer::{InferenceResult, InferenceVar};
+pub use infer::{could_unify, InferenceResult, InferenceVar};
 pub use lower::{
    associated_type_shorthand_candidates, callable_item_sig, CallableDefId, ImplTraitLoweringMode,
    TyDefId, TyLoweringContext, ValueTyDefId,
diff --git a/crates/hir_ty/src/tests/macros.rs b/crates/hir_ty/src/tests/macros.rs
index 7eda51866..01935ec99 100644
--- a/crates/hir_ty/src/tests/macros.rs
+++ b/crates/hir_ty/src/tests/macros.rs
@@ -226,12 +226,49 @@ fn expr_macro_expanded_in_stmts() {
        "#,
        expect![[r#"
            !0..8 'leta=();': ()
+            !0..8 'leta=();': ()
+            !3..4 'a': ()
+            !5..7 '()': ()
            57..84 '{     ...); } }': ()
        "#]],
    );
 }
 #[test]
+fn recurisve_macro_expanded_in_stmts() {
+    check_infer(
+        r#"
+        macro_rules! ng {
+            ([$($tts:tt)*]) => {
+                $($tts)*;
+            };
+            ([$($tts:tt)*] $head:tt $($rest:tt)*) => {
+                ng! {
+                    [$($tts)* $head] $($rest)*
+                }
+            };
+        }
+        fn foo() {
+            ng!([] let a = 3);
+            let b = a;
+        }
+        "#,
+        expect![[r#"
+            !0..7 'leta=3;': {unknown}
+            !0..7 'leta=3;': {unknown}
+            !0..13 'ng!{[leta=3]}': {unknown}
+            !0..13 'ng!{[leta=]3}': {unknown}
+            !0..13 'ng!{[leta]=3}': {unknown}
+            !3..4 'a': i32
+            !5..6 '3': i32
+            196..237 '{     ...= a; }': ()
+            229..230 'b': i32
+            233..234 'a': i32
+        "#]],
+    );
+}
+#[test]
 fn recursive_inner_item_macro_rules() {
    check_infer(
        r#"
@@ -246,7 +283,8 @@ fn recursive_inner_item_macro_rules() {
        "#,
        expect![[r#"
            !0..1 '1': i32
-            !0..7 'mac!($)': {unknown}
+            !0..26 'macro_...>{1};}': {unknown}
+            !0..26 'macro_...>{1};}': {unknown}
            107..143 '{     ...!(); }': ()
            129..130 'a': i32
        "#]],
diff --git a/crates/ide/src/diagnostics/fixes.rs b/crates/ide/src/diagnostics/fixes.rs
index 2f840909c..5fb3e2d91 100644
--- a/crates/ide/src/diagnostics/fixes.rs
+++ b/crates/ide/src/diagnostics/fixes.rs
@@ -210,7 +210,7 @@ fn missing_record_expr_field_fix(
    }
    let new_field = make::record_field(
        None,
-        make::name(record_expr_field.field_name()?.text()),
+        make::name(&record_expr_field.field_name()?.text()),
        make::ty(&new_field_type.display_source_code(sema.db, module.into()).ok()?),
    );
diff --git a/crates/ide/src/inlay_hints.rs b/crates/ide/src/inlay_hints.rs
index 16c04eeee..25f96222c 100644
--- a/crates/ide/src/inlay_hints.rs
+++ b/crates/ide/src/inlay_hints.rs
@@ -416,7 +416,7 @@ fn get_string_representation(expr: &ast::Expr) -> Option<String> {
    match expr {
        ast::Expr::MethodCallExpr(method_call_expr) => {
            let name_ref = method_call_expr.name_ref()?;
-            match name_ref.text() {
+            match name_ref.text().as_str() {
                "clone" => method_call_expr.receiver().map(|rec| rec.to_string()),
                name_ref => Some(name_ref.to_owned()),
            }
diff --git a/crates/ide/src/runnables.rs b/crates/ide/src/runnables.rs
index 5b488e2c5..7e4c5a078 100644
--- a/crates/ide/src/runnables.rs
+++ b/crates/ide/src/runnables.rs
@@ -226,7 +226,9 @@ pub(crate) fn runnable_fn(sema: &Semantics<RootDatabase>, def: hir::Function) ->
    let func = def.source(sema.db)?;
    let name_string = def.name(sema.db).to_string();
-    let kind = if name_string == "main" {
+    let root = def.krate(sema.db)?.root_module(sema.db);
+    let kind = if name_string == "main" && def.module(sema.db) == root {
        RunnableKind::Bin
    } else {
        let canonical_path = {
@@ -444,6 +446,10 @@ fn test_foo() {}
 #[bench]
 fn bench() {}
+mod not_a_root {
+    fn main() {}
+}
 "#,
            &[&BIN, &TEST, &TEST, &BENCH],
            expect![[r#"
diff --git a/crates/ide/src/syntax_highlighting/format.rs b/crates/ide/src/syntax_highlighting/format.rs
index e503abc93..5bbadb0f4 100644
--- a/crates/ide/src/syntax_highlighting/format.rs
+++ b/crates/ide/src/syntax_highlighting/format.rs
@@ -31,7 +31,7 @@ fn is_format_string(string: &ast::String) -> Option<()> {
    let parent = string.syntax().parent()?;
    let name = parent.parent().and_then(ast::MacroCall::cast)?.path()?.segment()?.name_ref()?;
-    if !matches!(name.text(), "format_args" | "format_args_nl") {
+    if !matches!(name.text().as_str(), "format_args" | "format_args_nl") {
        return None;
    }
diff --git a/crates/ide_assists/src/handlers/extract_struct_from_enum_variant.rs b/crates/ide_assists/src/handlers/extract_struct_from_enum_variant.rs
index 596c536a7..a8d6355bd 100644
--- a/crates/ide_assists/src/handlers/extract_struct_from_enum_variant.rs
+++ b/crates/ide_assists/src/handlers/extract_struct_from_enum_variant.rs
@@ -195,7 +195,7 @@ fn extract_struct_def(
 fn update_variant(rewriter: &mut SyntaxRewriter, variant: &ast::Variant) -> Option<()> {
    let name = variant.name()?;
-    let tuple_field = make::tuple_field(None, make::ty(name.text()));
+    let tuple_field = make::tuple_field(None, make::ty(&name.text()));
    let replacement = make::variant(
        name,
        Some(ast::FieldList::TupleFieldList(make::tuple_field_list(iter::once(tuple_field)))),
diff --git a/crates/ide_assists/src/handlers/generate_enum_is_method.rs b/crates/ide_assists/src/handlers/generate_enum_is_method.rs
index 7e181a480..a9f71a703 100644
--- a/crates/ide_assists/src/handlers/generate_enum_is_method.rs
+++ b/crates/ide_assists/src/handlers/generate_enum_is_method.rs
@@ -44,7 +44,7 @@ pub(crate) fn generate_enum_is_method(acc: &mut Assists, ctx: &AssistContext) ->
    };
    let enum_lowercase_name = to_lower_snake_case(&parent_enum.name()?.to_string());
-    let fn_name = format!("is_{}", &to_lower_snake_case(variant_name.text()));
+    let fn_name = format!("is_{}", &to_lower_snake_case(&variant_name.text()));
    // Return early if we've found an existing new fn
    let impl_def = find_struct_impl(&ctx, &parent_enum, &fn_name)?;
diff --git a/crates/ide_assists/src/handlers/generate_enum_projection_method.rs b/crates/ide_assists/src/handlers/generate_enum_projection_method.rs
index 871bcab50..e2f572ba3 100644
--- a/crates/ide_assists/src/handlers/generate_enum_projection_method.rs
+++ b/crates/ide_assists/src/handlers/generate_enum_projection_method.rs
@@ -132,7 +132,8 @@ fn generate_enum_projection_method(
        ast::StructKind::Unit => return None,
    };
-    let fn_name = format!("{}_{}", props.fn_name_prefix, &to_lower_snake_case(variant_name.text()));
+    let fn_name =
+        format!("{}_{}", props.fn_name_prefix, &to_lower_snake_case(&variant_name.text()));
    // Return early if we've found an existing new fn
    let impl_def = find_struct_impl(&ctx, &parent_enum, &fn_name)?;
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 4f0ef52ca..f872d20c8 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
@@ -165,7 +165,7 @@ fn impl_def_from_trait(
    }
    let impl_def = make::impl_trait(
        trait_path.clone(),
-        make::path_unqualified(make::path_segment(make::name_ref(annotated_name.text()))),
+        make::path_unqualified(make::path_segment(make::name_ref(&annotated_name.text()))),
    );
    let (impl_def, first_assoc_item) =
        add_trait_assoc_items_to_impl(sema, trait_items, trait_, impl_def, target_scope);
@@ -178,12 +178,13 @@ fn update_attribute(
    trait_name: &ast::NameRef,
    attr: &ast::Attr,
 ) {
+    let trait_name = trait_name.text();
    let new_attr_input = input
        .syntax()
        .descendants_with_tokens()
        .filter(|t| t.kind() == IDENT)
        .filter_map(|t| t.into_token().map(|t| t.text().to_string()))
-        .filter(|t| t != trait_name.text())
+        .filter(|t| t != &trait_name)
        .collect::<Vec<_>>();
    let has_more_derives = !new_attr_input.is_empty();
diff --git a/crates/ide_assists/src/utils.rs b/crates/ide_assists/src/utils.rs
index 728d174db..5f630ec75 100644
--- a/crates/ide_assists/src/utils.rs
+++ b/crates/ide_assists/src/utils.rs
@@ -246,7 +246,7 @@ fn invert_special_case(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Opti
            let method = mce.name_ref()?;
            let arg_list = mce.arg_list()?;
-            let method = match method.text() {
+            let method = match method.text().as_str() {
                "is_some" => "is_none",
                "is_none" => "is_some",
                "is_ok" => "is_err",
@@ -443,7 +443,7 @@ fn generate_impl_text_inner(adt: &ast::Adt, trait_text: Option<&str>, code: &str
        buf.push_str(trait_text);
        buf.push_str(" for ");
    }
-    buf.push_str(adt.name().unwrap().text());
+    buf.push_str(&adt.name().unwrap().text());
    if let Some(generic_params) = generic_params {
        let lifetime_params = generic_params
            .lifetime_params()
diff --git a/crates/ide_completion/src/item.rs b/crates/ide_completion/src/item.rs
index 9a4b5217a..cc4ac9ea2 100644
--- a/crates/ide_completion/src/item.rs
+++ b/crates/ide_completion/src/item.rs
@@ -122,7 +122,7 @@ impl fmt::Debug for CompletionItem {
    }
 }
-#[derive(Debug, Clone, Copy, Ord, PartialOrd, Eq, PartialEq, Default)]
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
 pub struct CompletionRelevance {
    /// This is set in cases like these:
    ///
@@ -134,31 +134,41 @@ pub struct CompletionRelevance {
    /// }
    /// ```
    pub exact_name_match: bool,
+    /// See CompletionRelevanceTypeMatch doc comments for cases where this is set.
+    pub type_match: Option<CompletionRelevanceTypeMatch>,
    /// This is set in cases like these:
    ///
    /// ```
-    /// fn f(spam: String) {}
+    /// fn foo(a: u32) {
-    /// fn main {
+    ///     let b = 0;
-    ///     let foo = String::new();
+    ///     $0 // `a` and `b` are local
-    ///     f($0) // type of local matches the type of param
    /// }
    /// ```
-    pub exact_type_match: bool,
+    pub is_local: bool,
+}
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub enum CompletionRelevanceTypeMatch {
    /// This is set in cases like these:
    ///
    /// ```
-    /// fn foo(bar: u32) {
+    /// enum Option<T> { Some(T), None }
-    ///     $0 // `bar` is local
+    /// fn f(a: Option<u32>) {}
+    /// fn main {
+    ///     f(Option::N$0) // type `Option<T>` could unify with `Option<u32>`
    /// }
    /// ```
+    CouldUnify,
+    /// This is set in cases like these:
    ///
    /// ```
-    /// fn foo() {
+    /// fn f(spam: String) {}
-    ///     let bar = 0;
+    /// fn main {
-    ///     $0 // `bar` is local
+    ///     let foo = String::new();
+    ///     f($0) // type of local matches the type of param
    /// }
    /// ```
-    pub is_local: bool,
+    Exact,
 }
 impl CompletionRelevance {
@@ -177,9 +187,11 @@ impl CompletionRelevance {
        if self.exact_name_match {
            score += 1;
        }
-        if self.exact_type_match {
+        score += match self.type_match {
-            score += 3;
+            Some(CompletionRelevanceTypeMatch::Exact) => 4,
-        }
+            Some(CompletionRelevanceTypeMatch::CouldUnify) => 3,
+            None => 0,
+        };
        if self.is_local {
            score += 1;
        }
@@ -342,7 +354,7 @@ impl CompletionItem {
        // match, but with exact type match set because self.ref_match
        // is only set if there is an exact type match.
        let mut relevance = self.relevance;
-        relevance.exact_type_match = true;
+        relevance.type_match = Some(CompletionRelevanceTypeMatch::Exact);
        self.ref_match.map(|mutability| (mutability, relevance))
    }
@@ -523,7 +535,7 @@ mod tests {
    use itertools::Itertools;
    use test_utils::assert_eq_text;
-    use super::CompletionRelevance;
+    use super::{CompletionRelevance, CompletionRelevanceTypeMatch};
    /// Check that these are CompletionRelevance are sorted in ascending order
    /// by their relevance score.
@@ -576,15 +588,22 @@ mod tests {
                is_local: true,
                ..CompletionRelevance::default()
            }],
-            vec![CompletionRelevance { exact_type_match: true, ..CompletionRelevance::default() }],
+            vec![CompletionRelevance {
+                type_match: Some(CompletionRelevanceTypeMatch::CouldUnify),
+                ..CompletionRelevance::default()
+            }],
+            vec![CompletionRelevance {
+                type_match: Some(CompletionRelevanceTypeMatch::Exact),
+                ..CompletionRelevance::default()
+            }],
            vec![CompletionRelevance {
                exact_name_match: true,
-                exact_type_match: true,
+                type_match: Some(CompletionRelevanceTypeMatch::Exact),
                ..CompletionRelevance::default()
            }],
            vec![CompletionRelevance {
                exact_name_match: true,
-                exact_type_match: true,
+                type_match: Some(CompletionRelevanceTypeMatch::Exact),
                is_local: true,
            }],
        ];
diff --git a/crates/ide_completion/src/render.rs b/crates/ide_completion/src/render.rs
index 9ce49074f..1a762d3dc 100644
--- a/crates/ide_completion/src/render.rs
+++ b/crates/ide_completion/src/render.rs
@@ -20,8 +20,8 @@ use ide_db::{
 use syntax::TextRange;
 use crate::{
-    item::ImportEdit, CompletionContext, CompletionItem, CompletionItemKind, CompletionKind,
+    item::{CompletionRelevanceTypeMatch, ImportEdit},
-    CompletionRelevance,
+    CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, CompletionRelevance,
 };
 use crate::render::{enum_variant::render_variant, function::render_fn, macro_::render_macro};
@@ -143,7 +143,7 @@ impl<'a> Render<'a> {
            .set_deprecated(is_deprecated);
        item.set_relevance(CompletionRelevance {
-            exact_type_match: compute_exact_type_match(self.ctx.completion, ty),
+            type_match: compute_type_match(self.ctx.completion, ty),
            exact_name_match: compute_exact_name_match(self.ctx.completion, name.to_string()),
            ..CompletionRelevance::default()
        });
@@ -245,7 +245,7 @@ impl<'a> Render<'a> {
            }
            item.set_relevance(CompletionRelevance {
-                exact_type_match: compute_exact_type_match(self.ctx.completion, &ty),
+                type_match: compute_type_match(self.ctx.completion, &ty),
                exact_name_match: compute_exact_name_match(self.ctx.completion, &local_name),
                is_local: true,
                ..CompletionRelevance::default()
@@ -309,14 +309,24 @@ impl<'a> Render<'a> {
    }
 }
-fn compute_exact_type_match(ctx: &CompletionContext, completion_ty: &hir::Type) -> bool {
+fn compute_type_match(
-    match ctx.expected_type.as_ref() {
+    ctx: &CompletionContext,
-        Some(expected_type) => {
+    completion_ty: &hir::Type,
-            // We don't ever consider unit type to be an exact type match, since
+) -> Option<CompletionRelevanceTypeMatch> {
-            // nearly always this is not meaningful to the user.
+    let expected_type = ctx.expected_type.as_ref()?;
-            completion_ty == expected_type && !expected_type.is_unit()
-        }
+    // We don't ever consider unit type to be an exact type match, since
-        None => false,
+    // nearly always this is not meaningful to the user.
+    if expected_type.is_unit() {
+        return None;
+    }
+    if completion_ty == expected_type {
+        Some(CompletionRelevanceTypeMatch::Exact)
+    } else if expected_type.could_unify_with(completion_ty) {
+        Some(CompletionRelevanceTypeMatch::CouldUnify)
+    } else {
+        None
    }
 }
@@ -348,6 +358,7 @@ mod tests {
    use itertools::Itertools;
    use crate::{
+        item::CompletionRelevanceTypeMatch,
        test_utils::{check_edit, do_completion, get_all_items, TEST_CONFIG},
        CompletionKind, CompletionRelevance,
    };
@@ -360,7 +371,11 @@ mod tests {
    fn check_relevance(ra_fixture: &str, expect: Expect) {
        fn display_relevance(relevance: CompletionRelevance) -> String {
            let relevance_factors = vec![
-                (relevance.exact_type_match, "type"),
+                (relevance.type_match == Some(CompletionRelevanceTypeMatch::Exact), "type"),
+                (
+                    relevance.type_match == Some(CompletionRelevanceTypeMatch::CouldUnify),
+                    "type_could_unify",
+                ),
                (relevance.exact_name_match, "name"),
                (relevance.is_local, "local"),
            ]
@@ -533,7 +548,9 @@ fn main() { let _: m::Spam = S$0 }
                        detail: "(i32)",
                        relevance: CompletionRelevance {
                            exact_name_match: false,
-                            exact_type_match: true,
+                            type_match: Some(
+                                Exact,
+                            ),
                            is_local: false,
                        },
                        trigger_call_info: true,
@@ -559,7 +576,9 @@ fn main() { let _: m::Spam = S$0 }
                        detail: "()",
                        relevance: CompletionRelevance {
                            exact_name_match: false,
-                            exact_type_match: true,
+                            type_match: Some(
+                                Exact,
+                            ),
                            is_local: false,
                        },
                    },
@@ -1108,7 +1127,7 @@ fn main() {
                        detail: "S",
                        relevance: CompletionRelevance {
                            exact_name_match: true,
-                            exact_type_match: false,
+                            type_match: None,
                            is_local: true,
                        },
                        ref_match: "&mut ",
@@ -1353,4 +1372,34 @@ fn foo(f: Foo) { let _: &u32 = f.b$0 }
            "#]],
        );
    }
+    #[test]
+    fn generic_enum() {
+        check_relevance(
+            r#"
+enum Foo<T> { A(T), B }
+// bar() should not be an exact type match
+// because the generic parameters are different
+fn bar() -> Foo<u8> { Foo::B }
+// FIXME baz() should be an exact type match
+// because the types could unify, but it currently
+// is not. This is due to the T here being
+// TyKind::Placeholder rather than TyKind::Missing.
+fn baz<T>() -> Foo<T> { Foo::B }
+fn foo() {
+    let foo: Foo<u32> = Foo::B;
+    let _: Foo<u32> = f$0;
+}
+"#,
+            expect![[r#"
+                ev Foo::A(…) [type_could_unify]
+                ev Foo::B [type_could_unify]
+                lc foo [type+local]
+                en Foo []
+                fn baz() []
+                fn bar() []
+                fn foo() []
+            "#]],
+        );
+    }
 }
diff --git a/crates/ide_completion/src/render/enum_variant.rs b/crates/ide_completion/src/render/enum_variant.rs
index 374247b05..832f5ced1 100644
--- a/crates/ide_completion/src/render/enum_variant.rs
+++ b/crates/ide_completion/src/render/enum_variant.rs
@@ -6,7 +6,7 @@ use itertools::Itertools;
 use crate::{
    item::{CompletionItem, CompletionKind, ImportEdit},
-    render::{builder_ext::Params, compute_exact_type_match, compute_ref_match, RenderContext},
+    render::{builder_ext::Params, compute_ref_match, compute_type_match, RenderContext},
    CompletionRelevance,
 };
@@ -77,7 +77,7 @@ impl<'a> EnumRender<'a> {
        let ty = self.variant.parent_enum(self.ctx.completion.db).ty(self.ctx.completion.db);
        item.set_relevance(CompletionRelevance {
-            exact_type_match: compute_exact_type_match(self.ctx.completion, &ty),
+            type_match: compute_type_match(self.ctx.completion, &ty),
            ..CompletionRelevance::default()
        });
diff --git a/crates/ide_completion/src/render/function.rs b/crates/ide_completion/src/render/function.rs
index b1eba20e8..d681e2c91 100644
--- a/crates/ide_completion/src/render/function.rs
+++ b/crates/ide_completion/src/render/function.rs
@@ -8,7 +8,7 @@ use syntax::ast::Fn;
 use crate::{
    item::{CompletionItem, CompletionItemKind, CompletionKind, CompletionRelevance, ImportEdit},
    render::{
-        builder_ext::Params, compute_exact_name_match, compute_exact_type_match, compute_ref_match,
+        builder_ext::Params, compute_exact_name_match, compute_ref_match, compute_type_match,
        RenderContext,
    },
 };
@@ -73,7 +73,7 @@ impl<'a> FunctionRender<'a> {
        let ret_type = self.func.ret_type(self.ctx.db());
        item.set_relevance(CompletionRelevance {
-            exact_type_match: compute_exact_type_match(self.ctx.completion, &ret_type),
+            type_match: compute_type_match(self.ctx.completion, &ret_type),
            exact_name_match: compute_exact_name_match(self.ctx.completion, self.name.clone()),
            ..CompletionRelevance::default()
        });
diff --git a/crates/ide_db/src/defs.rs b/crates/ide_db/src/defs.rs
index 75167ff39..ab23dd7ac 100644
--- a/crates/ide_db/src/defs.rs
+++ b/crates/ide_db/src/defs.rs
@@ -343,7 +343,7 @@ impl NameRefClass {
                        hir::AssocItem::TypeAlias(it) => Some(*it),
                        _ => None,
                    })
-                    .find(|alias| &alias.name(sema.db).to_string() == name_ref.text())
+                    .find(|alias| &alias.name(sema.db).to_string() == &name_ref.text())
                {
                    return Some(NameRefClass::Definition(Definition::ModuleDef(
                        ModuleDef::TypeAlias(ty),
diff --git a/crates/ide_db/src/helpers/import_assets.rs b/crates/ide_db/src/helpers/import_assets.rs
index 1881c746f..3deb0d159 100644
--- a/crates/ide_db/src/helpers/import_assets.rs
+++ b/crates/ide_db/src/helpers/import_assets.rs
@@ -288,7 +288,7 @@ fn path_applicable_imports(
                import_for_item(
                    sema.db,
                    mod_path,
-                    unresolved_first_segment,
+                    &unresolved_first_segment,
                    &unresolved_qualifier,
                    item,
                )
diff --git a/crates/ide_db/src/helpers/insert_use.rs b/crates/ide_db/src/helpers/insert_use.rs
index 20c195f82..e681ced80 100644
--- a/crates/ide_db/src/helpers/insert_use.rs
+++ b/crates/ide_db/src/helpers/insert_use.rs
@@ -509,7 +509,7 @@ impl ImportGroup {
            PathSegmentKind::SelfKw => ImportGroup::ThisModule,
            PathSegmentKind::SuperKw => ImportGroup::SuperModule,
            PathSegmentKind::CrateKw => ImportGroup::ThisCrate,
-            PathSegmentKind::Name(name) => match name.text() {
+            PathSegmentKind::Name(name) => match name.text().as_str() {
                "std" => ImportGroup::Std,
                "core" => ImportGroup::Std,
                _ => ImportGroup::ExternCrate,
diff --git a/crates/ide_ssr/src/resolving.rs b/crates/ide_ssr/src/resolving.rs
index dc7835473..541da4122 100644
--- a/crates/ide_ssr/src/resolving.rs
+++ b/crates/ide_ssr/src/resolving.rs
@@ -150,7 +150,7 @@ impl Resolver<'_, '_> {
    fn path_contains_placeholder(&self, path: &ast::Path) -> bool {
        if let Some(segment) = path.segment() {
            if let Some(name_ref) = segment.name_ref() {
-                if self.placeholders_by_stand_in.contains_key(name_ref.text()) {
+                if self.placeholders_by_stand_in.contains_key(name_ref.text().as_str()) {
                    return true;
                }
            }
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 25169005f..530c8a5a4 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -1138,7 +1138,7 @@ mod tests {
                (
                    "&arg",
                    Some(
-                        "fffffffa",
+                        "fffffff9",
                    ),
                ),
                (
diff --git a/crates/syntax/src/ast/make.rs b/crates/syntax/src/ast/make.rs
index c08f2c14f..c6a7b99b7 100644
--- a/crates/syntax/src/ast/make.rs
+++ b/crates/syntax/src/ast/make.rs
@@ -268,14 +268,14 @@ pub fn arg_list(args: impl IntoIterator<Item = ast::Expr>) -> ast::ArgList {
 }
 pub fn ident_pat(name: ast::Name) -> ast::IdentPat {
-    return from_text(name.text());
+    return from_text(&name.text());
    fn from_text(text: &str) -> ast::IdentPat {
        ast_from_text(&format!("fn f({}: ())", text))
    }
 }
 pub fn ident_mut_pat(name: ast::Name) -> ast::IdentPat {
-    return from_text(name.text());
+    return from_text(&name.text());
    fn from_text(text: &str) -> ast::IdentPat {
        ast_from_text(&format!("fn f(mut {}: ())", text))
diff --git a/crates/syntax/src/ast/node_ext.rs b/crates/syntax/src/ast/node_ext.rs
index bdf907a21..2772d7364 100644
--- a/crates/syntax/src/ast/node_ext.rs
+++ b/crates/syntax/src/ast/node_ext.rs
@@ -8,23 +8,23 @@ use parser::SyntaxKind;
 use crate::{
    ast::{self, support, AstNode, AstToken, AttrsOwner, NameOwner, SyntaxNode},
-    SmolStr, SyntaxElement, SyntaxToken, T,
+    SmolStr, SyntaxElement, SyntaxToken, TokenText, T,
 };
 impl ast::Lifetime {
-    pub fn text(&self) -> &str {
+    pub fn text(&self) -> TokenText {
        text_of_first_token(self.syntax())
    }
 }
 impl ast::Name {
-    pub fn text(&self) -> &str {
+    pub fn text(&self) -> TokenText {
        text_of_first_token(self.syntax())
    }
 }
 impl ast::NameRef {
-    pub fn text(&self) -> &str {
+    pub fn text(&self) -> TokenText {
        text_of_first_token(self.syntax())
    }
@@ -33,10 +33,11 @@ impl ast::NameRef {
    }
 }
-fn text_of_first_token(node: &SyntaxNode) -> &str {
+fn text_of_first_token(node: &SyntaxNode) -> TokenText {
-    let t =
+    let first_token =
-        node.green().children().next().and_then(|it| it.into_token()).unwrap().text().to_string();
+        node.green().children().next().and_then(|it| it.into_token()).unwrap().to_owned();
-    Box::leak(Box::new(t))
+    TokenText(first_token)
 }
 pub enum Macro {
@@ -378,7 +379,7 @@ impl fmt::Display for NameOrNameRef {
 }
 impl NameOrNameRef {
-    pub fn text(&self) -> &str {
+    pub fn text(&self) -> TokenText {
        match self {
            NameOrNameRef::Name(name) => name.text(),
            NameOrNameRef::NameRef(name_ref) => name_ref.text(),
diff --git a/crates/syntax/src/lib.rs b/crates/syntax/src/lib.rs
index 2a5c61171..90de6bef6 100644
--- a/crates/syntax/src/lib.rs
+++ b/crates/syntax/src/lib.rs
@@ -29,6 +29,7 @@ mod syntax_error;
 mod parsing;
 mod validation;
 mod ptr;
+mod token_text;
 #[cfg(test)]
 mod tests;
@@ -55,6 +56,7 @@ pub use crate::{
        SyntaxElement, SyntaxElementChildren, SyntaxNode, SyntaxNodeChildren, SyntaxToken,
        SyntaxTreeBuilder,
    },
+    token_text::TokenText,
 };
 pub use parser::{SyntaxKind, T};
 pub use rowan::{
diff --git a/crates/syntax/src/token_text.rs b/crates/syntax/src/token_text.rs
new file mode 100644
index 000000000..d2ed0a12a
--- /dev/null
+++ b/crates/syntax/src/token_text.rs
@@ -0,0 +1,77 @@
+//! Yet another version of owned string, backed by a syntax tree token.
+use std::{cmp::Ordering, fmt, ops};
+pub struct TokenText(pub(crate) rowan::GreenToken);
+impl TokenText {
+    pub fn as_str(&self) -> &str {
+        self.0.text()
+    }
+}
+impl ops::Deref for TokenText {
+    type Target = str;
+    fn deref(&self) -> &str {
+        self.as_str()
+    }
+}
+impl AsRef<str> for TokenText {
+    fn as_ref(&self) -> &str {
+        self.as_str()
+    }
+}
+impl From<TokenText> for String {
+    fn from(token_text: TokenText) -> Self {
+        token_text.as_str().into()
+    }
+}
+impl PartialEq<&'_ str> for TokenText {
+    fn eq(&self, other: &&str) -> bool {
+        self.as_str() == *other
+    }
+}
+impl PartialEq<TokenText> for &'_ str {
+    fn eq(&self, other: &TokenText) -> bool {
+        other == self
+    }
+}
+impl PartialEq<String> for TokenText {
+    fn eq(&self, other: &String) -> bool {
+        self.as_str() == other.as_str()
+    }
+}
+impl PartialEq<TokenText> for String {
+    fn eq(&self, other: &TokenText) -> bool {
+        other == self
+    }
+}
+impl PartialEq for TokenText {
+    fn eq(&self, other: &TokenText) -> bool {
+        self.as_str() == other.as_str()
+    }
+}
+impl Eq for TokenText {}
+impl Ord for TokenText {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.as_str().cmp(other.as_str())
+    }
+}
+impl PartialOrd for TokenText {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+impl fmt::Display for TokenText {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self.as_str(), f)
+    }
+}
+impl fmt::Debug for TokenText {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(self.as_str(), f)
+    }
+}