18 files changed, 154 insertions, 199 deletions
diff --git a/crates/assists/src/handlers/extract_assignment.rs b/crates/assists/src/handlers/extract_assignment.rs
index 281cf5d24..ae99598c0 100644
--- a/crates/assists/src/handlers/extract_assignment.rs
+++ b/crates/assists/src/handlers/extract_assignment.rs
@@ -1,4 +1,3 @@
-use hir::AsName;
 use syntax::{
    ast::{self, edit::AstNodeEdit, make},
    AstNode,
@@ -38,15 +37,23 @@ use crate::{
 // }
 // ```
 pub(crate) fn extract_assigment(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let name = ctx.find_node_at_offset::<ast::NameRef>()?.as_name();
+    let assign_expr = ctx.find_node_at_offset::<ast::BinExpr>()?;
+    let name_expr = if assign_expr.op_kind()? == ast::BinOp::Assignment {
+        assign_expr.lhs()?
+    } else {
+        return None;
+    };
    let (old_stmt, new_stmt) = if let Some(if_expr) = ctx.find_node_at_offset::<ast::IfExpr>() {
        (
            ast::Expr::cast(if_expr.syntax().to_owned())?,
-            exprify_if(&if_expr, &name)?.indent(if_expr.indent_level()),
+            exprify_if(&if_expr, &ctx.sema, &name_expr)?.indent(if_expr.indent_level()),
        )
    } else if let Some(match_expr) = ctx.find_node_at_offset::<ast::MatchExpr>() {
-        (ast::Expr::cast(match_expr.syntax().to_owned())?, exprify_match(&match_expr, &name)?)
+        (
+            ast::Expr::cast(match_expr.syntax().to_owned())?,
+            exprify_match(&match_expr, &ctx.sema, &name_expr)?,
+        )
    } else {
        return None;
    };
@@ -58,18 +65,22 @@ pub(crate) fn extract_assigment(acc: &mut Assists, ctx: &AssistContext) -> Optio
        "Extract assignment",
        old_stmt.syntax().text_range(),
        move |edit| {
-            edit.replace(old_stmt.syntax().text_range(), format!("{} = {};", name, expr_stmt));
+            edit.replace(old_stmt.syntax().text_range(), format!("{} = {};", name_expr, expr_stmt));
        },
    )
 }
-fn exprify_match(match_expr: &ast::MatchExpr, name: &hir::Name) -> Option<ast::Expr> {
+fn exprify_match(
+    match_expr: &ast::MatchExpr,
+    sema: &hir::Semantics<ide_db::RootDatabase>,
+    name: &ast::Expr,
+) -> Option<ast::Expr> {
    let new_arm_list = match_expr
        .match_arm_list()?
        .arms()
        .map(|arm| {
            if let ast::Expr::BlockExpr(block) = arm.expr()? {
-                let new_block = exprify_block(&block, name)?.indent(block.indent_level());
+                let new_block = exprify_block(&block, sema, name)?.indent(block.indent_level());
                Some(arm.replace_descendant(block, new_block))
            } else {
                None
@@ -82,21 +93,31 @@ fn exprify_match(match_expr: &ast::MatchExpr, name: &hir::Name) -> Option<ast::E
    Some(make::expr_match(match_expr.expr()?, new_arm_list))
 }
-fn exprify_if(statement: &ast::IfExpr, name: &hir::Name) -> Option<ast::Expr> {
+fn exprify_if(
-    let then_branch = exprify_block(&statement.then_branch()?, name)?;
+    statement: &ast::IfExpr,
+    sema: &hir::Semantics<ide_db::RootDatabase>,
+    name: &ast::Expr,
+) -> Option<ast::Expr> {
+    let then_branch = exprify_block(&statement.then_branch()?, sema, name)?;
    let else_branch = match statement.else_branch()? {
-        ast::ElseBranch::Block(ref block) => ast::ElseBranch::Block(exprify_block(block, name)?),
+        ast::ElseBranch::Block(ref block) => {
+            ast::ElseBranch::Block(exprify_block(block, sema, name)?)
+        }
        ast::ElseBranch::IfExpr(expr) => {
            mark::hit!(test_extract_assigment_chained_if);
            ast::ElseBranch::IfExpr(ast::IfExpr::cast(
-                exprify_if(&expr, name)?.syntax().to_owned(),
+                exprify_if(&expr, sema, name)?.syntax().to_owned(),
            )?)
        }
    };
    Some(make::expr_if(statement.condition()?, then_branch, Some(else_branch)))
 }
-fn exprify_block(block: &ast::BlockExpr, name: &hir::Name) -> Option<ast::BlockExpr> {
+fn exprify_block(
+    block: &ast::BlockExpr,
+    sema: &hir::Semantics<ide_db::RootDatabase>,
+    name: &ast::Expr,
+) -> Option<ast::BlockExpr> {
    if block.expr().is_some() {
        return None;
    }
@@ -106,8 +127,7 @@ fn exprify_block(block: &ast::BlockExpr, name: &hir::Name) -> Option<ast::BlockE
    if let ast::Stmt::ExprStmt(stmt) = stmt {
        if let ast::Expr::BinExpr(expr) = stmt.expr()? {
-            if expr.op_kind()? == ast::BinOp::Assignment
+            if expr.op_kind()? == ast::BinOp::Assignment && is_equivalent(sema, &expr.lhs()?, name)
-                && &expr.lhs()?.name_ref()?.as_name() == name
            {
                // The last statement in the block is an assignment to the name we want
                return Some(make::block_expr(stmts, Some(expr.rhs()?)));
@@ -117,6 +137,29 @@ fn exprify_block(block: &ast::BlockExpr, name: &hir::Name) -> Option<ast::BlockE
    None
 }
+fn is_equivalent(
+    sema: &hir::Semantics<ide_db::RootDatabase>,
+    expr0: &ast::Expr,
+    expr1: &ast::Expr,
+) -> bool {
+    match (expr0, expr1) {
+        (ast::Expr::FieldExpr(field_expr0), ast::Expr::FieldExpr(field_expr1)) => {
+            mark::hit!(test_extract_assignment_field_assignment);
+            sema.resolve_field(field_expr0) == sema.resolve_field(field_expr1)
+        }
+        (ast::Expr::PathExpr(path0), ast::Expr::PathExpr(path1)) => {
+            let path0 = path0.path();
+            let path1 = path1.path();
+            if let (Some(path0), Some(path1)) = (path0, path1) {
+                sema.resolve_path(&path0) == sema.resolve_path(&path1)
+            } else {
+                false
+            }
+        }
+        _ => false,
+    }
+}
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -322,4 +365,36 @@ fn foo() {
 }"#,
        )
    }
+    #[test]
+    fn test_extract_assignment_field_assignment() {
+        mark::check!(test_extract_assignment_field_assignment);
+        check_assist(
+            extract_assigment,
+            r#"
+struct A(usize);
+fn foo() {
+    let mut a = A(1);
+    if true {
+        <|>a.0 = 2;
+    } else {
+        a.0 = 3;
+    }
+}"#,
+            r#"
+struct A(usize);
+fn foo() {
+    let mut a = A(1);
+    a.0 = if true {
+        2
+    } else {
+        3
+    };
+}"#,
+        )
+    }
 }
diff --git a/crates/cfg/Cargo.toml b/crates/cfg/Cargo.toml
index c68e391c1..73247d130 100644
--- a/crates/cfg/Cargo.toml
+++ b/crates/cfg/Cargo.toml
@@ -17,4 +17,4 @@ tt = { path = "../tt", version = "0.0.0" }
 [dev-dependencies]
 mbe = { path = "../mbe" }
 syntax = { path = "../syntax" }
-expect-test = "1.0"
+expect-test = "1.1"
diff --git a/crates/completion/Cargo.toml b/crates/completion/Cargo.toml
index 78e93e78e..99a1bdd54 100644
--- a/crates/completion/Cargo.toml
+++ b/crates/completion/Cargo.toml
@@ -28,4 +28,4 @@ test_utils = { path = "../test_utils", version = "0.0.0" }
 hir = { path = "../hir", version = "0.0.0" }
 [dev-dependencies]
-expect-test = "1.0"
+expect-test = "1.1"
diff --git a/crates/hir_def/Cargo.toml b/crates/hir_def/Cargo.toml
index e8b581e2f..7ef966cd2 100644
--- a/crates/hir_def/Cargo.toml
+++ b/crates/hir_def/Cargo.toml
@@ -33,4 +33,4 @@ cfg = { path = "../cfg", version = "0.0.0" }
 tt = { path = "../tt", version = "0.0.0" }
 [dev-dependencies]
-expect-test = "1.0"
+expect-test = "1.1"
diff --git a/crates/hir_def/src/diagnostics.rs b/crates/hir_def/src/diagnostics.rs
index c71266dc0..ab3f059ce 100644
--- a/crates/hir_def/src/diagnostics.rs
+++ b/crates/hir_def/src/diagnostics.rs
@@ -133,6 +133,10 @@ impl Diagnostic for InactiveCode {
 // This diagnostic is shown when a procedural macro can not be found. This usually means that
 // procedural macro support is simply disabled (and hence is only a weak hint instead of an error),
 // but can also indicate project setup problems.
+//
+// If you are seeing a lot of "proc macro not expanded" warnings, you can add this option to the
+// `rust-analyzer.diagnostics.disabled` list to prevent them from showing. Alternatively you can
+// enable support for procedural macros (see `rust-analyzer.procMacro.enable`).
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct UnresolvedProcMacro {
    pub file: HirFileId,
diff --git a/crates/hir_def/src/path/lower.rs b/crates/hir_def/src/path/lower.rs
index 9518ac109..8a01e6eea 100644
--- a/crates/hir_def/src/path/lower.rs
+++ b/crates/hir_def/src/path/lower.rs
@@ -123,7 +123,7 @@ pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path>
    // We follow what it did anyway :)
    if segments.len() == 1 && kind == PathKind::Plain {
        if let Some(_macro_call) = path.syntax().parent().and_then(ast::MacroCall::cast) {
-            if let Some(crate_id) = hygiene.local_inner_macros(path) {
+            if let Some(crate_id) = hygiene.local_inner_macros() {
                kind = PathKind::DollarCrate(crate_id);
            }
        }
diff --git a/crates/hir_expand/src/hygiene.rs b/crates/hir_expand/src/hygiene.rs
index 6042e15b2..7ab0a5e52 100644
--- a/crates/hir_expand/src/hygiene.rs
+++ b/crates/hir_expand/src/hygiene.rs
@@ -2,94 +2,30 @@
 //!
 //! Specifically, `ast` + `Hygiene` allows you to create a `Name`. Note that, at
 //! this moment, this is horribly incomplete and handles only `$crate`.
-use std::sync::Arc;
-use arena::{Arena, Idx};
 use base_db::CrateId;
 use either::Either;
-use mbe::Origin;
+use syntax::ast;
-use syntax::{ast, AstNode};
 use crate::{
    db::AstDatabase,
    name::{AsName, Name},
-    ExpansionInfo, HirFileId, HirFileIdRepr, MacroCallId, MacroDefKind,
+    HirFileId, HirFileIdRepr, MacroCallId, MacroDefKind,
 };
 #[derive(Clone, Debug)]
 pub struct Hygiene {
-    frames: Option<Arc<HygieneFrames>>,
+    // This is what `$crate` expands to
-}
+    def_crate: Option<CrateId>,
-impl Hygiene {
-    pub fn new(db: &dyn AstDatabase, file_id: HirFileId) -> Hygiene {
-        Hygiene { frames: Some(Arc::new(HygieneFrames::new(db, file_id.clone()))) }
-    }
-    pub fn new_unhygienic() -> Hygiene {
-        Hygiene { frames: None }
-    }
-    // FIXME: this should just return name
-    pub fn name_ref_to_name(&self, name_ref: ast::NameRef) -> Either<Name, CrateId> {
-        if let Some(frames) = &self.frames {
-            if name_ref.text() == "$crate" {
-                if let Some(krate) = frames.root_crate(&name_ref) {
-                    return Either::Right(krate);
-                }
-            }
-        }
-        Either::Left(name_ref.as_name())
-    }
-    pub fn local_inner_macros(&self, path: ast::Path) -> Option<CrateId> {
-        let frames = self.frames.as_ref()?;
-        let mut token = path.syntax().first_token()?;
-        let mut current = frames.first();
-        while let Some((frame, data)) =
-            current.and_then(|it| Some((it, it.expansion.as_ref()?.map_token_up(&token)?)))
-        {
-            let (mapped, origin) = data;
-            if origin == Origin::Def {
-                return if frame.local_inner { frame.krate } else { None };
-            }
-            current = Some(&frames.0[frame.call_site?]);
-            token = mapped.value;
-        }
-        None
-    }
-}
-#[derive(Default, Debug)]
-struct HygieneFrames(Arena<HygieneFrame>);
-#[derive(Clone, Debug)]
-struct HygieneFrame {
-    expansion: Option<ExpansionInfo>,
    // Indicate this is a local inner macro
    local_inner: bool,
-    krate: Option<CrateId>,
-    call_site: Option<Idx<HygieneFrame>>,
-    def_site: Option<Idx<HygieneFrame>>,
 }
-impl HygieneFrames {
+impl Hygiene {
-    fn new(db: &dyn AstDatabase, file_id: HirFileId) -> Self {
+    pub fn new(db: &dyn AstDatabase, file_id: HirFileId) -> Hygiene {
-        let mut frames = HygieneFrames::default();
+        let (def_crate, local_inner) = match file_id.0 {
-        frames.add(db, file_id);
-        frames
-    }
-    fn add(&mut self, db: &dyn AstDatabase, file_id: HirFileId) -> Option<Idx<HygieneFrame>> {
-        let (krate, local_inner) = match file_id.0 {
            HirFileIdRepr::FileId(_) => (None, false),
            HirFileIdRepr::MacroFile(macro_file) => match macro_file.macro_call_id {
-                MacroCallId::EagerMacro(_id) => (None, false),
                MacroCallId::LazyMacro(id) => {
                    let loc = db.lookup_intern_macro(id);
                    match loc.def.kind {
@@ -100,68 +36,31 @@ impl HygieneFrames {
                        MacroDefKind::ProcMacro(_) => (None, false),
                    }
                }
+                MacroCallId::EagerMacro(_id) => (None, false),
            },
        };
+        Hygiene { def_crate, local_inner }
-        let expansion = file_id.expansion_info(db);
-        let expansion = match expansion {
-            None => {
-                return Some(self.0.alloc(HygieneFrame {
-                    expansion: None,
-                    local_inner,
-                    krate,
-                    call_site: None,
-                    def_site: None,
-                }));
-            }
-            Some(it) => it,
-        };
-        let def_site = expansion.def.clone();
-        let call_site = expansion.arg.file_id;
-        let idx = self.0.alloc(HygieneFrame {
-            expansion: Some(expansion),
-            local_inner,
-            krate,
-            call_site: None,
-            def_site: None,
-        });
-        self.0[idx].call_site = self.add(db, call_site);
-        self.0[idx].def_site = def_site.and_then(|it| self.add(db, it.file_id));
-        Some(idx)
    }
-    fn first(&self) -> Option<&HygieneFrame> {
+    pub fn new_unhygienic() -> Hygiene {
-        self.0.iter().next().map(|it| it.1)
+        Hygiene { def_crate: None, local_inner: false }
    }
-    fn root_crate(&self, name_ref: &ast::NameRef) -> Option<CrateId> {
+    // FIXME: this should just return name
-        let mut token = name_ref.syntax().first_token()?;
+    pub fn name_ref_to_name(&self, name_ref: ast::NameRef) -> Either<Name, CrateId> {
-        let first = self.first()?;
+        if let Some(def_crate) = self.def_crate {
-        let mut result = first.krate;
+            if name_ref.text() == "$crate" {
-        let mut current = Some(first);
+                return Either::Right(def_crate);
+            }
-        while let Some((frame, (mapped, origin))) =
-            current.and_then(|it| Some((it, it.expansion.as_ref()?.map_token_up(&token)?)))
-        {
-            result = frame.krate;
-            let site = match origin {
-                Origin::Def => frame.def_site,
-                Origin::Call => frame.call_site,
-            };
-            let site = match site {
-                None => break,
-                Some(it) => it,
-            };
-            current = Some(&self.0[site]);
-            token = mapped.value;
        }
+        Either::Left(name_ref.as_name())
+    }
-        result
+    pub fn local_inner_macros(&self) -> Option<CrateId> {
+        if self.local_inner {
+            self.def_crate
+        } else {
+            None
+        }
    }
 }
diff --git a/crates/hir_expand/src/lib.rs b/crates/hir_expand/src/lib.rs
index 5b6734a5f..3fa1b1d77 100644
--- a/crates/hir_expand/src/lib.rs
+++ b/crates/hir_expand/src/lib.rs
@@ -340,8 +340,11 @@ impl ExpansionInfo {
        Some(self.expanded.with_value(token))
    }
-    pub fn map_token_up(&self, token: &SyntaxToken) -> Option<(InFile<SyntaxToken>, Origin)> {
+    pub fn map_token_up(
-        let token_id = self.exp_map.token_by_range(token.text_range())?;
+        &self,
+        token: InFile<&SyntaxToken>,
+    ) -> Option<(InFile<SyntaxToken>, Origin)> {
+        let token_id = self.exp_map.token_by_range(token.value.text_range())?;
        let (token_id, origin) = self.macro_def.0.map_id_up(token_id);
        let (token_map, tt) = match origin {
@@ -356,7 +359,7 @@ impl ExpansionInfo {
            ),
        };
-        let range = token_map.range_by_token(token_id)?.by_kind(token.kind())?;
+        let range = token_map.range_by_token(token_id)?.by_kind(token.value.kind())?;
        let token = algo::find_covering_element(&tt.value, range + tt.value.text_range().start())
            .into_token()?;
        Some((tt.with_value(token), origin))
@@ -492,7 +495,7 @@ fn ascend_call_token(
    expansion: &ExpansionInfo,
    token: InFile<SyntaxToken>,
 ) -> Option<InFile<SyntaxToken>> {
-    let (mapped, origin) = expansion.map_token_up(&token.value)?;
+    let (mapped, origin) = expansion.map_token_up(token.as_ref())?;
    if origin != Origin::Call {
        return None;
    }
diff --git a/crates/hir_ty/Cargo.toml b/crates/hir_ty/Cargo.toml
index 2dfccd191..3d1778590 100644
--- a/crates/hir_ty/Cargo.toml
+++ b/crates/hir_ty/Cargo.toml
@@ -31,7 +31,7 @@ syntax = { path = "../syntax", version = "0.0.0" }
 test_utils = { path = "../test_utils", version = "0.0.0" }
 [dev-dependencies]
-expect-test = "1.0"
+expect-test = "1.1"
 tracing = "0.1"
 tracing-subscriber = { version = "0.2", default-features = false, features = ["env-filter", "registry"] }
 tracing-tree = { version = "0.1.4" }
diff --git a/crates/hir_ty/src/tests/macros.rs b/crates/hir_ty/src/tests/macros.rs
index c64f0b5b5..1953da7be 100644
--- a/crates/hir_ty/src/tests/macros.rs
+++ b/crates/hir_ty/src/tests/macros.rs
@@ -371,37 +371,6 @@ expand!();
 }
 #[test]
-fn infer_macro_with_dollar_crate_in_def_site() {
-    check_types(
-        r#"
-//- /main.rs crate:main deps:foo
-use foo::expand;
-macro_rules! list {
-    ($($tt:tt)*) => { $($tt)* }
-}
-fn test() {
-    let r = expand!();
-    r;
-  //^ u128
-}
-//- /lib.rs crate:foo
-#[macro_export]
-macro_rules! expand {
-    () => { list!($crate::m!()) };
-}
-#[macro_export]
-macro_rules! m {
-    () => { 0u128 };
-}
-"#,
-    );
-}
-#[test]
 fn infer_type_value_non_legacy_macro_use_as() {
    check_infer(
        r#"
diff --git a/crates/ide/Cargo.toml b/crates/ide/Cargo.toml
index f1544dbe0..bb28cca4d 100644
--- a/crates/ide/Cargo.toml
+++ b/crates/ide/Cargo.toml
@@ -36,4 +36,4 @@ completion = { path = "../completion", version = "0.0.0" }
 hir = { path = "../hir", version = "0.0.0" }
 [dev-dependencies]
-expect-test = "1.0"
+expect-test = "1.1"
diff --git a/crates/ide_db/Cargo.toml b/crates/ide_db/Cargo.toml
index ebe53c8ee..d3d3dc688 100644
--- a/crates/ide_db/Cargo.toml
+++ b/crates/ide_db/Cargo.toml
@@ -32,4 +32,4 @@ test_utils = { path = "../test_utils", version = "0.0.0" }
 hir = { path = "../hir", version = "0.0.0" }
 [dev-dependencies]
-expect-test = "1.0"
+expect-test = "1.1"
diff --git a/crates/mbe/src/mbe_expander/matcher.rs b/crates/mbe/src/mbe_expander/matcher.rs
index 385b46601..ab5f87c48 100644
--- a/crates/mbe/src/mbe_expander/matcher.rs
+++ b/crates/mbe/src/mbe_expander/matcher.rs
@@ -150,7 +150,7 @@ fn match_subtree(
                    res.add_err(err!("leftover tokens"));
                }
            }
-            Op::Var { name, kind, .. } => {
+            Op::Var { name, kind } => {
                let kind = match kind {
                    Some(k) => k,
                    None => {
diff --git a/crates/mbe/src/mbe_expander/transcriber.rs b/crates/mbe/src/mbe_expander/transcriber.rs
index 57f3f104d..720531237 100644
--- a/crates/mbe/src/mbe_expander/transcriber.rs
+++ b/crates/mbe/src/mbe_expander/transcriber.rs
@@ -100,8 +100,8 @@ fn expand_subtree(
                err = err.or(e);
                arena.push(tt.into());
            }
-            Op::Var { name, id, .. } => {
+            Op::Var { name, .. } => {
-                let ExpandResult { value: fragment, err: e } = expand_var(ctx, &name, *id);
+                let ExpandResult { value: fragment, err: e } = expand_var(ctx, &name);
                err = err.or(e);
                push_fragment(arena, fragment);
            }
@@ -118,10 +118,12 @@ fn expand_subtree(
    ExpandResult { value: tt::Subtree { delimiter: template.delimiter, token_trees: tts }, err }
 }
-fn expand_var(ctx: &mut ExpandCtx, v: &SmolStr, id: tt::TokenId) -> ExpandResult<Fragment> {
+fn expand_var(ctx: &mut ExpandCtx, v: &SmolStr) -> ExpandResult<Fragment> {
    if v == "crate" {
        // We simply produce identifier `$crate` here. And it will be resolved when lowering ast to Path.
-        let tt = tt::Leaf::from(tt::Ident { text: "$crate".into(), id }).into();
+        let tt =
+            tt::Leaf::from(tt::Ident { text: "$crate".into(), id: tt::TokenId::unspecified() })
+                .into();
        ExpandResult::ok(Fragment::Tokens(tt))
    } else if !ctx.bindings.contains(v) {
        // Note that it is possible to have a `$var` inside a macro which is not bound.
@@ -140,8 +142,14 @@ fn expand_var(ctx: &mut ExpandCtx, v: &SmolStr, id: tt::TokenId) -> ExpandResult
        let tt = tt::Subtree {
            delimiter: None,
            token_trees: vec![
-                tt::Leaf::from(tt::Punct { char: '$', spacing: tt::Spacing::Alone, id }).into(),
+                tt::Leaf::from(tt::Punct {
-                tt::Leaf::from(tt::Ident { text: v.clone(), id }).into(),
+                    char: '$',
+                    spacing: tt::Spacing::Alone,
+                    id: tt::TokenId::unspecified(),
+                })
+                .into(),
+                tt::Leaf::from(tt::Ident { text: v.clone(), id: tt::TokenId::unspecified() })
+                    .into(),
            ],
        }
        .into();
diff --git a/crates/mbe/src/parser.rs b/crates/mbe/src/parser.rs
index 77cc739b6..2f3ebc831 100644
--- a/crates/mbe/src/parser.rs
+++ b/crates/mbe/src/parser.rs
@@ -8,7 +8,7 @@ use crate::{tt_iter::TtIter, ExpandError, MetaTemplate};
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub(crate) enum Op {
-    Var { name: SmolStr, kind: Option<SmolStr>, id: tt::TokenId },
+    Var { name: SmolStr, kind: Option<SmolStr> },
    Repeat { subtree: MetaTemplate, kind: RepeatKind, separator: Option<Separator> },
    Leaf(tt::Leaf),
    Subtree(MetaTemplate),
@@ -106,21 +106,18 @@ fn next_op<'a>(first: &tt::TokenTree, src: &mut TtIter<'a>, mode: Mode) -> Resul
                        }
                        let name = UNDERSCORE.clone();
                        let kind = eat_fragment_kind(src, mode)?;
-                        let id = punct.id;
+                        Op::Var { name, kind }
-                        Op::Var { name, kind, id }
                    }
                    tt::Leaf::Ident(ident) => {
                        let name = ident.text.clone();
                        let kind = eat_fragment_kind(src, mode)?;
-                        let id = ident.id;
+                        Op::Var { name, kind }
-                        Op::Var { name, kind, id }
                    }
                    tt::Leaf::Literal(lit) => {
                        if is_boolean_literal(&lit) {
                            let name = lit.text.clone();
                            let kind = eat_fragment_kind(src, mode)?;
-                            let id = lit.id;
+                            Op::Var { name, kind }
-                            Op::Var { name, kind, id }
                        } else {
                            bail!("bad var 2");
                        }
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index 0a63593fb..af7b86ead 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -62,7 +62,7 @@ proc_macro_srv = { path = "../proc_macro_srv", version = "0.0.0" }
 winapi = "0.3.8"
 [dev-dependencies]
-expect-test = "1.0"
+expect-test = "1.1"
 test_utils = { path = "../test_utils" }
 mbe = { path = "../mbe" }
 tt = { path = "../tt" }
diff --git a/crates/ssr/Cargo.toml b/crates/ssr/Cargo.toml
index 339eda86a..cc8136d22 100644
--- a/crates/ssr/Cargo.toml
+++ b/crates/ssr/Cargo.toml
@@ -21,4 +21,4 @@ hir = { path = "../hir", version = "0.0.0" }
 test_utils = { path = "../test_utils", version = "0.0.0" }
 [dev-dependencies]
-expect-test = "1.0"
+expect-test = "1.1"
diff --git a/crates/syntax/Cargo.toml b/crates/syntax/Cargo.toml
index 5d8389ade..181077944 100644
--- a/crates/syntax/Cargo.toml
+++ b/crates/syntax/Cargo.toml
@@ -33,4 +33,4 @@ profile = { path = "../profile", version = "0.0.0" }
 [dev-dependencies]
 walkdir = "2.3.1"
 rayon = "1"
-expect-test = "1.0"
+expect-test = "1.1"