45 files changed, 3176 insertions, 489 deletions
diff --git a/crates/assists/src/handlers/extract_function.rs b/crates/assists/src/handlers/extract_function.rs
new file mode 100644
index 000000000..d876eabca
--- /dev/null
+++ b/crates/assists/src/handlers/extract_function.rs
@@ -0,0 +1,2159 @@
+use either::Either;
+use hir::{HirDisplay, Local};
+use ide_db::{
+    defs::{Definition, NameRefClass},
+    search::{FileReference, ReferenceAccess, SearchScope},
+};
+use itertools::Itertools;
+use stdx::format_to;
+use syntax::{
+    algo::SyntaxRewriter,
+    ast::{
+        self,
+        edit::{AstNodeEdit, IndentLevel},
+        AstNode,
+    },
+    AstToken, Direction, SyntaxElement,
+    SyntaxKind::{self, BLOCK_EXPR, BREAK_EXPR, COMMENT, PATH_EXPR, RETURN_EXPR},
+    SyntaxNode, SyntaxToken, TextRange, TextSize, TokenAtOffset, T,
+};
+use test_utils::mark;
+use crate::{
+    assist_context::{AssistContext, Assists},
+    AssistId,
+};
+// Assist: extract_function
+//
+// Extracts selected statements into new function.
+//
+// ```
+// fn main() {
+//     let n = 1;
+//     $0let m = n + 2;
+//     let k = m + n;$0
+//     let g = 3;
+// }
+// ```
+// ->
+// ```
+// fn main() {
+//     let n = 1;
+//     fun_name(n);
+//     let g = 3;
+// }
+//
+// fn $0fun_name(n: i32) {
+//     let m = n + 2;
+//     let k = m + n;
+// }
+// ```
+pub(crate) fn extract_function(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    if ctx.frange.range.is_empty() {
+        return None;
+    }
+    let node = ctx.covering_element();
+    if node.kind() == COMMENT {
+        mark::hit!(extract_function_in_comment_is_not_applicable);
+        return None;
+    }
+    let node = element_to_node(node);
+    let body = extraction_target(&node, ctx.frange.range)?;
+    let vars_used_in_body = vars_used_in_body(ctx, &body);
+    let self_param = self_param_from_usages(ctx, &body, &vars_used_in_body);
+    let anchor = if self_param.is_some() { Anchor::Method } else { Anchor::Freestanding };
+    let insert_after = scope_for_fn_insertion(&body, anchor)?;
+    let module = ctx.sema.scope(&insert_after).module()?;
+    let vars_defined_in_body_and_outlive = vars_defined_in_body_and_outlive(ctx, &body);
+    let ret_ty = body_return_ty(ctx, &body)?;
+    // FIXME: we compute variables that outlive here just to check `never!` condition
+    //        this requires traversing whole `body` (cheap) and finding all references (expensive)
+    //        maybe we can move this check to `edit` closure somehow?
+    if stdx::never!(!vars_defined_in_body_and_outlive.is_empty() && !ret_ty.is_unit()) {
+        // We should not have variables that outlive body if we have expression block
+        return None;
+    }
+    let target_range = match &body {
+        FunctionBody::Expr(expr) => expr.syntax().text_range(),
+        FunctionBody::Span { .. } => ctx.frange.range,
+    };
+    acc.add(
+        AssistId("extract_function", crate::AssistKind::RefactorExtract),
+        "Extract into function",
+        target_range,
+        move |builder| {
+            let params = extracted_function_params(ctx, &body, &vars_used_in_body);
+            let fun = Function {
+                name: "fun_name".to_string(),
+                self_param: self_param.map(|(_, pat)| pat),
+                params,
+                ret_ty,
+                body,
+                vars_defined_in_body_and_outlive,
+            };
+            builder.replace(target_range, format_replacement(ctx, &fun));
+            let new_indent = IndentLevel::from_node(&insert_after);
+            let old_indent = fun.body.indent_level();
+            let fn_def = format_function(ctx, module, &fun, old_indent, new_indent);
+            let insert_offset = insert_after.text_range().end();
+            builder.insert(insert_offset, fn_def);
+        },
+    )
+}
+#[derive(Debug)]
+struct Function {
+    name: String,
+    self_param: Option<ast::SelfParam>,
+    params: Vec<Param>,
+    ret_ty: RetType,
+    body: FunctionBody,
+    vars_defined_in_body_and_outlive: Vec<Local>,
+}
+#[derive(Debug)]
+struct Param {
+    var: Local,
+    ty: hir::Type,
+    has_usages_afterwards: bool,
+    has_mut_inside_body: bool,
+    is_copy: bool,
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum ParamKind {
+    Value,
+    MutValue,
+    SharedRef,
+    MutRef,
+}
+impl ParamKind {
+    fn is_ref(&self) -> bool {
+        matches!(self, ParamKind::SharedRef | ParamKind::MutRef)
+    }
+}
+impl Param {
+    fn kind(&self) -> ParamKind {
+        match (self.has_usages_afterwards, self.has_mut_inside_body, self.is_copy) {
+            (true, true, _) => ParamKind::MutRef,
+            (true, false, false) => ParamKind::SharedRef,
+            (false, true, _) => ParamKind::MutValue,
+            (true, false, true) | (false, false, _) => ParamKind::Value,
+        }
+    }
+    fn value_prefix(&self) -> &'static str {
+        match self.kind() {
+            ParamKind::Value | ParamKind::MutValue => "",
+            ParamKind::SharedRef => "&",
+            ParamKind::MutRef => "&mut ",
+        }
+    }
+    fn type_prefix(&self) -> &'static str {
+        match self.kind() {
+            ParamKind::Value | ParamKind::MutValue => "",
+            ParamKind::SharedRef => "&",
+            ParamKind::MutRef => "&mut ",
+        }
+    }
+    fn mut_pattern(&self) -> &'static str {
+        match self.kind() {
+            ParamKind::MutValue => "mut ",
+            _ => "",
+        }
+    }
+}
+#[derive(Debug)]
+enum RetType {
+    Expr(hir::Type),
+    Stmt,
+}
+impl RetType {
+    fn is_unit(&self) -> bool {
+        match self {
+            RetType::Expr(ty) => ty.is_unit(),
+            RetType::Stmt => true,
+        }
+    }
+    fn as_fn_ret(&self) -> Option<&hir::Type> {
+        match self {
+            RetType::Stmt => None,
+            RetType::Expr(ty) if ty.is_unit() => None,
+            RetType::Expr(ty) => Some(ty),
+        }
+    }
+}
+/// Semantically same as `ast::Expr`, but preserves identity when using only part of the Block
+#[derive(Debug)]
+enum FunctionBody {
+    Expr(ast::Expr),
+    Span { elements: Vec<SyntaxElement>, leading_indent: String },
+}
+impl FunctionBody {
+    fn from_whole_node(node: SyntaxNode) -> Option<Self> {
+        match node.kind() {
+            PATH_EXPR => None,
+            BREAK_EXPR => ast::BreakExpr::cast(node).and_then(|e| e.expr()).map(Self::Expr),
+            RETURN_EXPR => ast::ReturnExpr::cast(node).and_then(|e| e.expr()).map(Self::Expr),
+            BLOCK_EXPR => ast::BlockExpr::cast(node)
+                .filter(|it| it.is_standalone())
+                .map(Into::into)
+                .map(Self::Expr),
+            _ => ast::Expr::cast(node).map(Self::Expr),
+        }
+    }
+    fn from_range(node: &SyntaxNode, range: TextRange) -> Option<FunctionBody> {
+        let mut first = node.token_at_offset(range.start()).left_biased()?;
+        let last = node.token_at_offset(range.end()).right_biased()?;
+        let mut leading_indent = String::new();
+        let leading_trivia = first
+            .siblings_with_tokens(Direction::Prev)
+            .skip(1)
+            .take_while(|e| e.kind() == SyntaxKind::WHITESPACE && e.as_token().is_some());
+        for e in leading_trivia {
+            let token = e.as_token().unwrap();
+            let text = token.text();
+            match text.rfind('\n') {
+                Some(pos) => {
+                    leading_indent = text[pos..].to_owned();
+                    break;
+                }
+                None => first = token.clone(),
+            }
+        }
+        let mut elements: Vec<_> = first
+            .siblings_with_tokens(Direction::Next)
+            .take_while(|e| e.as_token() != Some(&last))
+            .collect();
+        if !(last.kind() == SyntaxKind::WHITESPACE && last.text().lines().count() <= 2) {
+            elements.push(last.into());
+        }
+        Some(FunctionBody::Span { elements, leading_indent })
+    }
+    fn indent_level(&self) -> IndentLevel {
+        match &self {
+            FunctionBody::Expr(expr) => IndentLevel::from_node(expr.syntax()),
+            FunctionBody::Span { elements, .. } => elements
+                .iter()
+                .filter_map(SyntaxElement::as_node)
+                .map(IndentLevel::from_node)
+                .min_by_key(|level| level.0)
+                .expect("body must contain at least one node"),
+        }
+    }
+    fn tail_expr(&self) -> Option<ast::Expr> {
+        match &self {
+            FunctionBody::Expr(expr) => Some(expr.clone()),
+            FunctionBody::Span { elements, .. } => {
+                elements.iter().rev().find_map(|e| e.as_node()).cloned().and_then(ast::Expr::cast)
+            }
+        }
+    }
+    fn descendants(&self) -> impl Iterator<Item = SyntaxNode> + '_ {
+        match self {
+            FunctionBody::Expr(expr) => Either::Right(expr.syntax().descendants()),
+            FunctionBody::Span { elements, .. } => Either::Left(
+                elements
+                    .iter()
+                    .filter_map(SyntaxElement::as_node)
+                    .flat_map(SyntaxNode::descendants),
+            ),
+        }
+    }
+    fn text_range(&self) -> TextRange {
+        match self {
+            FunctionBody::Expr(expr) => expr.syntax().text_range(),
+            FunctionBody::Span { elements, .. } => TextRange::new(
+                elements.first().unwrap().text_range().start(),
+                elements.last().unwrap().text_range().end(),
+            ),
+        }
+    }
+    fn contains_range(&self, range: TextRange) -> bool {
+        self.text_range().contains_range(range)
+    }
+    fn preceedes_range(&self, range: TextRange) -> bool {
+        self.text_range().end() <= range.start()
+    }
+    fn contains_node(&self, node: &SyntaxNode) -> bool {
+        self.contains_range(node.text_range())
+    }
+}
+impl HasTokenAtOffset for FunctionBody {
+    fn token_at_offset(&self, offset: TextSize) -> TokenAtOffset<SyntaxToken> {
+        match self {
+            FunctionBody::Expr(expr) => expr.syntax().token_at_offset(offset),
+            FunctionBody::Span { elements, .. } => {
+                stdx::always!(self.text_range().contains(offset));
+                let mut iter = elements
+                    .iter()
+                    .filter(|element| element.text_range().contains_inclusive(offset));
+                let element1 = iter.next().expect("offset does not fall into body");
+                let element2 = iter.next();
+                stdx::always!(iter.next().is_none(), "> 2 tokens at offset");
+                let t1 = match element1 {
+                    syntax::NodeOrToken::Node(node) => node.token_at_offset(offset),
+                    syntax::NodeOrToken::Token(token) => TokenAtOffset::Single(token.clone()),
+                };
+                let t2 = element2.map(|e| match e {
+                    syntax::NodeOrToken::Node(node) => node.token_at_offset(offset),
+                    syntax::NodeOrToken::Token(token) => TokenAtOffset::Single(token.clone()),
+                });
+                match t2 {
+                    Some(t2) => match (t1.clone().right_biased(), t2.clone().left_biased()) {
+                        (Some(e1), Some(e2)) => TokenAtOffset::Between(e1, e2),
+                        (Some(_), None) => t1,
+                        (None, _) => t2,
+                    },
+                    None => t1,
+                }
+            }
+        }
+    }
+}
+/// node or token's parent
+fn element_to_node(node: SyntaxElement) -> SyntaxNode {
+    match node {
+        syntax::NodeOrToken::Node(n) => n,
+        syntax::NodeOrToken::Token(t) => t.parent(),
+    }
+}
+/// Try to guess what user wants to extract
+///
+/// We have basically have two cases:
+/// * We want whole node, like `loop {}`, `2 + 2`, `{ let n = 1; }` exprs.
+///   Then we can use `ast::Expr`
+/// * We want a few statements for a block. E.g.
+///   ```rust,no_run
+///   fn foo() -> i32 {
+///     let m = 1;
+///     $0
+///     let n = 2;
+///     let k = 3;
+///     k + n
+///     $0
+///   }
+///   ```
+///
+fn extraction_target(node: &SyntaxNode, selection_range: TextRange) -> Option<FunctionBody> {
+    // we have selected exactly the expr node
+    // wrap it before anything else
+    if node.text_range() == selection_range {
+        let body = FunctionBody::from_whole_node(node.clone());
+        if body.is_some() {
+            return body;
+        }
+    }
+    // we have selected a few statements in a block
+    // so covering_element returns the whole block
+    if node.kind() == BLOCK_EXPR {
+        let body = FunctionBody::from_range(&node, selection_range);
+        if body.is_some() {
+            return body;
+        }
+    }
+    // we have selected single statement
+    // `from_whole_node` failed because (let) statement is not and expression
+    // so we try to expand covering_element to parent and repeat the previous
+    if let Some(parent) = node.parent() {
+        if parent.kind() == BLOCK_EXPR {
+            let body = FunctionBody::from_range(&parent, selection_range);
+            if body.is_some() {
+                return body;
+            }
+        }
+    }
+    // select the closest containing expr (both ifs are used)
+    std::iter::once(node.clone()).chain(node.ancestors()).find_map(FunctionBody::from_whole_node)
+}
+/// list local variables that are referenced in `body`
+fn vars_used_in_body(ctx: &AssistContext, body: &FunctionBody) -> Vec<Local> {
+    // FIXME: currently usages inside macros are not found
+    body.descendants()
+        .filter_map(ast::NameRef::cast)
+        .filter_map(|name_ref| NameRefClass::classify(&ctx.sema, &name_ref))
+        .map(|name_kind| name_kind.referenced(ctx.db()))
+        .filter_map(|definition| match definition {
+            Definition::Local(local) => Some(local),
+            _ => None,
+        })
+        .unique()
+        .collect()
+}
+/// find `self` param, that was not defined inside `body`
+///
+/// It should skip `self` params from impls inside `body`
+fn self_param_from_usages(
+    ctx: &AssistContext,
+    body: &FunctionBody,
+    vars_used_in_body: &[Local],
+) -> Option<(Local, ast::SelfParam)> {
+    let mut iter = vars_used_in_body
+        .iter()
+        .filter(|var| var.is_self(ctx.db()))
+        .map(|var| (var, var.source(ctx.db())))
+        .filter(|(_, src)| is_defined_before(ctx, body, src))
+        .filter_map(|(&node, src)| match src.value {
+            Either::Right(it) => Some((node, it)),
+            Either::Left(_) => {
+                stdx::never!(false, "Local::is_self returned true, but source is IdentPat");
+                None
+            }
+        });
+    let self_param = iter.next();
+    stdx::always!(
+        iter.next().is_none(),
+        "body references two different self params, both defined outside"
+    );
+    self_param
+}
+/// find variables that should be extracted as params
+///
+/// Computes additional info that affects param type and mutability
+fn extracted_function_params(
+    ctx: &AssistContext,
+    body: &FunctionBody,
+    vars_used_in_body: &[Local],
+) -> Vec<Param> {
+    vars_used_in_body
+        .iter()
+        .filter(|var| !var.is_self(ctx.db()))
+        .map(|node| (node, node.source(ctx.db())))
+        .filter(|(_, src)| is_defined_before(ctx, body, src))
+        .filter_map(|(&node, src)| {
+            if src.value.is_left() {
+                Some(node)
+            } else {
+                stdx::never!(false, "Local::is_self returned false, but source is SelfParam");
+                None
+            }
+        })
+        .map(|var| {
+            let usages = LocalUsages::find(ctx, var);
+            let ty = var.ty(ctx.db());
+            let is_copy = ty.is_copy(ctx.db());
+            Param {
+                var,
+                ty,
+                has_usages_afterwards: has_usages_after_body(&usages, body),
+                has_mut_inside_body: has_exclusive_usages(ctx, &usages, body),
+                is_copy,
+            }
+        })
+        .collect()
+}
+fn has_usages_after_body(usages: &LocalUsages, body: &FunctionBody) -> bool {
+    usages.iter().any(|reference| body.preceedes_range(reference.range))
+}
+/// checks if relevant var is used with `&mut` access inside body
+fn has_exclusive_usages(ctx: &AssistContext, usages: &LocalUsages, body: &FunctionBody) -> bool {
+    usages
+        .iter()
+        .filter(|reference| body.contains_range(reference.range))
+        .any(|reference| reference_is_exclusive(reference, body, ctx))
+}
+/// checks if this reference requires `&mut` access inside body
+fn reference_is_exclusive(
+    reference: &FileReference,
+    body: &FunctionBody,
+    ctx: &AssistContext,
+) -> bool {
+    // we directly modify variable with set: `n = 0`, `n += 1`
+    if reference.access == Some(ReferenceAccess::Write) {
+        return true;
+    }
+    // we take `&mut` reference to variable: `&mut v`
+    let path = match path_element_of_reference(body, reference) {
+        Some(path) => path,
+        None => return false,
+    };
+    expr_require_exclusive_access(ctx, &path).unwrap_or(false)
+}
+/// checks if this expr requires `&mut` access, recurses on field access
+fn expr_require_exclusive_access(ctx: &AssistContext, expr: &ast::Expr) -> Option<bool> {
+    let parent = expr.syntax().parent()?;
+    if let Some(bin_expr) = ast::BinExpr::cast(parent.clone()) {
+        if bin_expr.op_kind()?.is_assignment() {
+            return Some(bin_expr.lhs()?.syntax() == expr.syntax());
+        }
+        return Some(false);
+    }
+    if let Some(ref_expr) = ast::RefExpr::cast(parent.clone()) {
+        return Some(ref_expr.mut_token().is_some());
+    }
+    if let Some(method_call) = ast::MethodCallExpr::cast(parent.clone()) {
+        let func = ctx.sema.resolve_method_call(&method_call)?;
+        let self_param = func.self_param(ctx.db())?;
+        let access = self_param.access(ctx.db());
+        return Some(matches!(access, hir::Access::Exclusive));
+    }
+    if let Some(field) = ast::FieldExpr::cast(parent) {
+        return expr_require_exclusive_access(ctx, &field.into());
+    }
+    Some(false)
+}
+/// Container of local varaible usages
+///
+/// Semanticall same as `UsageSearchResult`, but provides more convenient interface
+struct LocalUsages(ide_db::search::UsageSearchResult);
+impl LocalUsages {
+    fn find(ctx: &AssistContext, var: Local) -> Self {
+        Self(
+            Definition::Local(var)
+                .usages(&ctx.sema)
+                .in_scope(SearchScope::single_file(ctx.frange.file_id))
+                .all(),
+        )
+    }
+    fn iter(&self) -> impl Iterator<Item = &FileReference> + '_ {
+        self.0.iter().flat_map(|(_, rs)| rs.iter())
+    }
+}
+trait HasTokenAtOffset {
+    fn token_at_offset(&self, offset: TextSize) -> TokenAtOffset<SyntaxToken>;
+}
+impl HasTokenAtOffset for SyntaxNode {
+    fn token_at_offset(&self, offset: TextSize) -> TokenAtOffset<SyntaxToken> {
+        SyntaxNode::token_at_offset(&self, offset)
+    }
+}
+/// find relevant `ast::PathExpr` for reference
+///
+/// # Preconditions
+///
+/// `node` must cover `reference`, that is `node.text_range().contains_range(reference.range)`
+fn path_element_of_reference(
+    node: &dyn HasTokenAtOffset,
+    reference: &FileReference,
+) -> Option<ast::Expr> {
+    let token = node.token_at_offset(reference.range.start()).right_biased().or_else(|| {
+        stdx::never!(false, "cannot find token at variable usage: {:?}", reference);
+        None
+    })?;
+    let path = token.ancestors().find_map(ast::Expr::cast).or_else(|| {
+        stdx::never!(false, "cannot find path parent of variable usage: {:?}", token);
+        None
+    })?;
+    stdx::always!(matches!(path, ast::Expr::PathExpr(_)));
+    Some(path)
+}
+/// list local variables defined inside `body`
+fn vars_defined_in_body(body: &FunctionBody, ctx: &AssistContext) -> Vec<Local> {
+    // FIXME: this doesn't work well with macros
+    //        see https://github.com/rust-analyzer/rust-analyzer/pull/7535#discussion_r570048550
+    body.descendants()
+        .filter_map(ast::IdentPat::cast)
+        .filter_map(|let_stmt| ctx.sema.to_def(&let_stmt))
+        .unique()
+        .collect()
+}
+/// list local variables defined inside `body` that should be returned from extracted function
+fn vars_defined_in_body_and_outlive(ctx: &AssistContext, body: &FunctionBody) -> Vec<Local> {
+    let mut vars_defined_in_body = vars_defined_in_body(&body, ctx);
+    vars_defined_in_body.retain(|var| var_outlives_body(ctx, body, var));
+    vars_defined_in_body
+}
+/// checks if the relevant local was defined before(outside of) body
+fn is_defined_before(
+    ctx: &AssistContext,
+    body: &FunctionBody,
+    src: &hir::InFile<Either<ast::IdentPat, ast::SelfParam>>,
+) -> bool {
+    src.file_id.original_file(ctx.db()) == ctx.frange.file_id
+        && !body.contains_node(&either_syntax(&src.value))
+}
+fn either_syntax(value: &Either<ast::IdentPat, ast::SelfParam>) -> &SyntaxNode {
+    match value {
+        Either::Left(pat) => pat.syntax(),
+        Either::Right(it) => it.syntax(),
+    }
+}
+/// checks if local variable is used after(outside of) body
+fn var_outlives_body(ctx: &AssistContext, body: &FunctionBody, var: &Local) -> bool {
+    let usages = Definition::Local(*var)
+        .usages(&ctx.sema)
+        .in_scope(SearchScope::single_file(ctx.frange.file_id))
+        .all();
+    let mut usages = usages.iter().flat_map(|(_, rs)| rs.iter());
+    usages.any(|reference| body.preceedes_range(reference.range))
+}
+fn body_return_ty(ctx: &AssistContext, body: &FunctionBody) -> Option<RetType> {
+    match body.tail_expr() {
+        Some(expr) => {
+            let ty = ctx.sema.type_of_expr(&expr)?;
+            Some(RetType::Expr(ty))
+        }
+        None => Some(RetType::Stmt),
+    }
+}
+/// Where to put extracted function definition
+#[derive(Debug)]
+enum Anchor {
+    /// Extract free function and put right after current top-level function
+    Freestanding,
+    /// Extract method and put right after current function in the impl-block
+    Method,
+}
+/// find where to put extracted function definition
+///
+/// Function should be put right after returned node
+fn scope_for_fn_insertion(body: &FunctionBody, anchor: Anchor) -> Option<SyntaxNode> {
+    match body {
+        FunctionBody::Expr(e) => scope_for_fn_insertion_node(e.syntax(), anchor),
+        FunctionBody::Span { elements, .. } => {
+            let node = elements.iter().find_map(|e| e.as_node())?;
+            scope_for_fn_insertion_node(&node, anchor)
+        }
+    }
+}
+fn scope_for_fn_insertion_node(node: &SyntaxNode, anchor: Anchor) -> Option<SyntaxNode> {
+    let mut ancestors = node.ancestors().peekable();
+    let mut last_ancestor = None;
+    while let Some(next_ancestor) = ancestors.next() {
+        match next_ancestor.kind() {
+            SyntaxKind::SOURCE_FILE => break,
+            SyntaxKind::ITEM_LIST => {
+                if !matches!(anchor, Anchor::Freestanding) {
+                    continue;
+                }
+                if ancestors.peek().map(SyntaxNode::kind) == Some(SyntaxKind::MODULE) {
+                    break;
+                }
+            }
+            SyntaxKind::ASSOC_ITEM_LIST => {
+                if !matches!(anchor, Anchor::Method) {
+                    continue;
+                }
+                if ancestors.peek().map(SyntaxNode::kind) == Some(SyntaxKind::IMPL) {
+                    break;
+                }
+            }
+            _ => {}
+        }
+        last_ancestor = Some(next_ancestor);
+    }
+    last_ancestor
+}
+fn format_replacement(ctx: &AssistContext, fun: &Function) -> String {
+    let mut buf = String::new();
+    match fun.vars_defined_in_body_and_outlive.as_slice() {
+        [] => {}
+        [var] => format_to!(buf, "let {} = ", var.name(ctx.db()).unwrap()),
+        [v0, vs @ ..] => {
+            buf.push_str("let (");
+            format_to!(buf, "{}", v0.name(ctx.db()).unwrap());
+            for var in vs {
+                format_to!(buf, ", {}", var.name(ctx.db()).unwrap());
+            }
+            buf.push_str(") = ");
+        }
+    }
+    if fun.self_param.is_some() {
+        format_to!(buf, "self.");
+    }
+    format_to!(buf, "{}(", fun.name);
+    format_arg_list_to(&mut buf, fun, ctx);
+    format_to!(buf, ")");
+    if fun.ret_ty.is_unit() {
+        format_to!(buf, ";");
+    }
+    buf
+}
+fn format_arg_list_to(buf: &mut String, fun: &Function, ctx: &AssistContext) {
+    let mut it = fun.params.iter();
+    if let Some(param) = it.next() {
+        format_arg_to(buf, ctx, param);
+    }
+    for param in it {
+        buf.push_str(", ");
+        format_arg_to(buf, ctx, param);
+    }
+}
+fn format_arg_to(buf: &mut String, ctx: &AssistContext, param: &Param) {
+    format_to!(buf, "{}{}", param.value_prefix(), param.var.name(ctx.db()).unwrap());
+}
+fn format_function(
+    ctx: &AssistContext,
+    module: hir::Module,
+    fun: &Function,
+    old_indent: IndentLevel,
+    new_indent: IndentLevel,
+) -> String {
+    let mut fn_def = String::new();
+    format_to!(fn_def, "\n\n{}fn $0{}(", new_indent, fun.name);
+    format_function_param_list_to(&mut fn_def, ctx, module, fun);
+    fn_def.push(')');
+    format_function_ret_to(&mut fn_def, ctx, module, fun);
+    fn_def.push_str(" {");
+    format_function_body_to(&mut fn_def, ctx, old_indent, new_indent, fun);
+    format_to!(fn_def, "{}}}", new_indent);
+    fn_def
+}
+fn format_function_param_list_to(
+    fn_def: &mut String,
+    ctx: &AssistContext,
+    module: hir::Module,
+    fun: &Function,
+) {
+    let mut it = fun.params.iter();
+    if let Some(self_param) = &fun.self_param {
+        format_to!(fn_def, "{}", self_param);
+    } else if let Some(param) = it.next() {
+        format_param_to(fn_def, ctx, module, param);
+    }
+    for param in it {
+        fn_def.push_str(", ");
+        format_param_to(fn_def, ctx, module, param);
+    }
+}
+fn format_param_to(fn_def: &mut String, ctx: &AssistContext, module: hir::Module, param: &Param) {
+    format_to!(
+        fn_def,
+        "{}{}: {}{}",
+        param.mut_pattern(),
+        param.var.name(ctx.db()).unwrap(),
+        param.type_prefix(),
+        format_type(&param.ty, ctx, module)
+    );
+}
+fn format_function_ret_to(
+    fn_def: &mut String,
+    ctx: &AssistContext,
+    module: hir::Module,
+    fun: &Function,
+) {
+    if let Some(ty) = fun.ret_ty.as_fn_ret() {
+        format_to!(fn_def, " -> {}", format_type(ty, ctx, module));
+    } else {
+        match fun.vars_defined_in_body_and_outlive.as_slice() {
+            [] => {}
+            [var] => {
+                format_to!(fn_def, " -> {}", format_type(&var.ty(ctx.db()), ctx, module));
+            }
+            [v0, vs @ ..] => {
+                format_to!(fn_def, " -> ({}", format_type(&v0.ty(ctx.db()), ctx, module));
+                for var in vs {
+                    format_to!(fn_def, ", {}", format_type(&var.ty(ctx.db()), ctx, module));
+                }
+                fn_def.push(')');
+            }
+        }
+    }
+}
+fn format_function_body_to(
+    fn_def: &mut String,
+    ctx: &AssistContext,
+    old_indent: IndentLevel,
+    new_indent: IndentLevel,
+    fun: &Function,
+) {
+    match &fun.body {
+        FunctionBody::Expr(expr) => {
+            fn_def.push('\n');
+            let expr = expr.dedent(old_indent).indent(new_indent + 1);
+            let expr = fix_param_usages(ctx, &fun.params, expr.syntax());
+            format_to!(fn_def, "{}{}", new_indent + 1, expr);
+            fn_def.push('\n');
+        }
+        FunctionBody::Span { elements, leading_indent } => {
+            format_to!(fn_def, "{}", leading_indent);
+            let new_indent_str = format!("\n{}", new_indent + 1);
+            for mut element in elements {
+                let new_ws;
+                if let Some(ws) = element.as_token().cloned().and_then(ast::Whitespace::cast) {
+                    let text = ws.syntax().text();
+                    if text.contains('\n') {
+                        let new_text = text.replace(&format!("\n{}", old_indent), &new_indent_str);
+                        new_ws = ast::make::tokens::whitespace(&new_text).into();
+                        element = &new_ws;
+                    }
+                }
+                match element {
+                    syntax::NodeOrToken::Node(node) => {
+                        format_to!(fn_def, "{}", fix_param_usages(ctx, &fun.params, node));
+                    }
+                    syntax::NodeOrToken::Token(token) => {
+                        format_to!(fn_def, "{}", token);
+                    }
+                }
+            }
+            if !fn_def.ends_with('\n') {
+                fn_def.push('\n');
+            }
+        }
+    }
+    match fun.vars_defined_in_body_and_outlive.as_slice() {
+        [] => {}
+        [var] => format_to!(fn_def, "{}{}\n", new_indent + 1, var.name(ctx.db()).unwrap()),
+        [v0, vs @ ..] => {
+            format_to!(fn_def, "{}({}", new_indent + 1, v0.name(ctx.db()).unwrap());
+            for var in vs {
+                format_to!(fn_def, ", {}", var.name(ctx.db()).unwrap());
+            }
+            fn_def.push_str(")\n");
+        }
+    }
+}
+fn format_type(ty: &hir::Type, ctx: &AssistContext, module: hir::Module) -> String {
+    ty.display_source_code(ctx.db(), module.into()).ok().unwrap_or_else(|| "()".to_string())
+}
+/// change all usages to account for added `&`/`&mut` for some params
+fn fix_param_usages(ctx: &AssistContext, params: &[Param], syntax: &SyntaxNode) -> SyntaxNode {
+    let mut rewriter = SyntaxRewriter::default();
+    for param in params {
+        if !param.kind().is_ref() {
+            continue;
+        }
+        let usages = LocalUsages::find(ctx, param.var);
+        let usages = usages
+            .iter()
+            .filter(|reference| syntax.text_range().contains_range(reference.range))
+            .filter_map(|reference| path_element_of_reference(syntax, reference));
+        for path in usages {
+            match path.syntax().ancestors().skip(1).find_map(ast::Expr::cast) {
+                Some(ast::Expr::MethodCallExpr(_)) | Some(ast::Expr::FieldExpr(_)) => {
+                    // do nothing
+                }
+                Some(ast::Expr::RefExpr(node))
+                    if param.kind() == ParamKind::MutRef && node.mut_token().is_some() =>
+                {
+                    rewriter.replace_ast(&node.clone().into(), &node.expr().unwrap());
+                }
+                Some(ast::Expr::RefExpr(node))
+                    if param.kind() == ParamKind::SharedRef && node.mut_token().is_none() =>
+                {
+                    rewriter.replace_ast(&node.clone().into(), &node.expr().unwrap());
+                }
+                Some(_) | None => {
+                    rewriter.replace_ast(&path, &ast::make::expr_prefix(T![*], path.clone()));
+                }
+            };
+        }
+    }
+    rewriter.rewrite(syntax)
+}
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable};
+    use super::*;
+    #[test]
+    fn no_args_from_binary_expr() {
+        check_assist(
+            extract_function,
+            r#"
+fn foo() {
+    foo($01 + 1$0);
+}"#,
+            r#"
+fn foo() {
+    foo(fun_name());
+}
+fn $0fun_name() -> i32 {
+    1 + 1
+}"#,
+        );
+    }
+    #[test]
+    fn no_args_from_binary_expr_in_module() {
+        check_assist(
+            extract_function,
+            r#"
+mod bar {
+    fn foo() {
+        foo($01 + 1$0);
+    }
+}"#,
+            r#"
+mod bar {
+    fn foo() {
+        foo(fun_name());
+    }
+    fn $0fun_name() -> i32 {
+        1 + 1
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn no_args_from_binary_expr_indented() {
+        check_assist(
+            extract_function,
+            r#"
+fn foo() {
+    $0{ 1 + 1 }$0;
+}"#,
+            r#"
+fn foo() {
+    fun_name();
+}
+fn $0fun_name() -> i32 {
+    { 1 + 1 }
+}"#,
+        );
+    }
+    #[test]
+    fn no_args_from_stmt_with_last_expr() {
+        check_assist(
+            extract_function,
+            r#"
+fn foo() -> i32 {
+    let k = 1;
+    $0let m = 1;
+    m + 1$0
+}"#,
+            r#"
+fn foo() -> i32 {
+    let k = 1;
+    fun_name()
+}
+fn $0fun_name() -> i32 {
+    let m = 1;
+    m + 1
+}"#,
+        );
+    }
+    #[test]
+    fn no_args_from_stmt_unit() {
+        check_assist(
+            extract_function,
+            r#"
+fn foo() {
+    let k = 3;
+    $0let m = 1;
+    let n = m + 1;$0
+    let g = 5;
+}"#,
+            r#"
+fn foo() {
+    let k = 3;
+    fun_name();
+    let g = 5;
+}
+fn $0fun_name() {
+    let m = 1;
+    let n = m + 1;
+}"#,
+        );
+    }
+    #[test]
+    fn no_args_if() {
+        check_assist(
+            extract_function,
+            r#"
+fn foo() {
+    $0if true { }$0
+}"#,
+            r#"
+fn foo() {
+    fun_name();
+}
+fn $0fun_name() {
+    if true { }
+}"#,
+        );
+    }
+    #[test]
+    fn no_args_if_else() {
+        check_assist(
+            extract_function,
+            r#"
+fn foo() -> i32 {
+    $0if true { 1 } else { 2 }$0
+}"#,
+            r#"
+fn foo() -> i32 {
+    fun_name()
+}
+fn $0fun_name() -> i32 {
+    if true { 1 } else { 2 }
+}"#,
+        );
+    }
+    #[test]
+    fn no_args_if_let_else() {
+        check_assist(
+            extract_function,
+            r#"
+fn foo() -> i32 {
+    $0if let true = false { 1 } else { 2 }$0
+}"#,
+            r#"
+fn foo() -> i32 {
+    fun_name()
+}
+fn $0fun_name() -> i32 {
+    if let true = false { 1 } else { 2 }
+}"#,
+        );
+    }
+    #[test]
+    fn no_args_match() {
+        check_assist(
+            extract_function,
+            r#"
+fn foo() -> i32 {
+    $0match true {
+        true => 1,
+        false => 2,
+    }$0
+}"#,
+            r#"
+fn foo() -> i32 {
+    fun_name()
+}
+fn $0fun_name() -> i32 {
+    match true {
+        true => 1,
+        false => 2,
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn no_args_while() {
+        check_assist(
+            extract_function,
+            r#"
+fn foo() {
+    $0while true { }$0
+}"#,
+            r#"
+fn foo() {
+    fun_name();
+}
+fn $0fun_name() {
+    while true { }
+}"#,
+        );
+    }
+    #[test]
+    fn no_args_for() {
+        check_assist(
+            extract_function,
+            r#"
+fn foo() {
+    $0for v in &[0, 1] { }$0
+}"#,
+            r#"
+fn foo() {
+    fun_name();
+}
+fn $0fun_name() {
+    for v in &[0, 1] { }
+}"#,
+        );
+    }
+    #[test]
+    fn no_args_from_loop_unit() {
+        check_assist(
+            extract_function,
+            r#"
+fn foo() {
+    $0loop {
+        let m = 1;
+    }$0
+}"#,
+            r#"
+fn foo() {
+    fun_name()
+}
+fn $0fun_name() -> ! {
+    loop {
+        let m = 1;
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn no_args_from_loop_with_return() {
+        check_assist(
+            extract_function,
+            r#"
+fn foo() {
+    let v = $0loop {
+        let m = 1;
+        break m;
+    }$0;
+}"#,
+            r#"
+fn foo() {
+    let v = fun_name();
+}
+fn $0fun_name() -> i32 {
+    loop {
+        let m = 1;
+        break m;
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn no_args_from_match() {
+        check_assist(
+            extract_function,
+            r#"
+fn foo() {
+    let v: i32 = $0match Some(1) {
+        Some(x) => x,
+        None => 0,
+    }$0;
+}"#,
+            r#"
+fn foo() {
+    let v: i32 = fun_name();
+}
+fn $0fun_name() -> i32 {
+    match Some(1) {
+        Some(x) => x,
+        None => 0,
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn argument_form_expr() {
+        check_assist(
+            extract_function,
+            r"
+fn foo() -> u32 {
+    let n = 2;
+    $0n+2$0
+}",
+            r"
+fn foo() -> u32 {
+    let n = 2;
+    fun_name(n)
+}
+fn $0fun_name(n: u32) -> u32 {
+    n+2
+}",
+        )
+    }
+    #[test]
+    fn argument_used_twice_form_expr() {
+        check_assist(
+            extract_function,
+            r"
+fn foo() -> u32 {
+    let n = 2;
+    $0n+n$0
+}",
+            r"
+fn foo() -> u32 {
+    let n = 2;
+    fun_name(n)
+}
+fn $0fun_name(n: u32) -> u32 {
+    n+n
+}",
+        )
+    }
+    #[test]
+    fn two_arguments_form_expr() {
+        check_assist(
+            extract_function,
+            r"
+fn foo() -> u32 {
+    let n = 2;
+    let m = 3;
+    $0n+n*m$0
+}",
+            r"
+fn foo() -> u32 {
+    let n = 2;
+    let m = 3;
+    fun_name(n, m)
+}
+fn $0fun_name(n: u32, m: u32) -> u32 {
+    n+n*m
+}",
+        )
+    }
+    #[test]
+    fn argument_and_locals() {
+        check_assist(
+            extract_function,
+            r"
+fn foo() -> u32 {
+    let n = 2;
+    $0let m = 1;
+    n + m$0
+}",
+            r"
+fn foo() -> u32 {
+    let n = 2;
+    fun_name(n)
+}
+fn $0fun_name(n: u32) -> u32 {
+    let m = 1;
+    n + m
+}",
+        )
+    }
+    #[test]
+    fn in_comment_is_not_applicable() {
+        mark::check!(extract_function_in_comment_is_not_applicable);
+        check_assist_not_applicable(extract_function, r"fn main() { 1 + /* $0comment$0 */ 1; }");
+    }
+    #[test]
+    fn part_of_expr_stmt() {
+        check_assist(
+            extract_function,
+            "
+fn foo() {
+    $01$0 + 1;
+}",
+            "
+fn foo() {
+    fun_name() + 1;
+}
+fn $0fun_name() -> i32 {
+    1
+}",
+        );
+    }
+    #[test]
+    fn function_expr() {
+        check_assist(
+            extract_function,
+            r#"
+fn foo() {
+    $0bar(1 + 1)$0
+}"#,
+            r#"
+fn foo() {
+    fun_name();
+}
+fn $0fun_name() {
+    bar(1 + 1)
+}"#,
+        )
+    }
+    #[test]
+    fn extract_from_nested() {
+        check_assist(
+            extract_function,
+            r"
+fn main() {
+    let x = true;
+    let tuple = match x {
+        true => ($02 + 2$0, true)
+        _ => (0, false)
+    };
+}",
+            r"
+fn main() {
+    let x = true;
+    let tuple = match x {
+        true => (fun_name(), true)
+        _ => (0, false)
+    };
+}
+fn $0fun_name() -> i32 {
+    2 + 2
+}",
+        );
+    }
+    #[test]
+    fn param_from_closure() {
+        check_assist(
+            extract_function,
+            r"
+fn main() {
+    let lambda = |x: u32| $0x * 2$0;
+}",
+            r"
+fn main() {
+    let lambda = |x: u32| fun_name(x);
+}
+fn $0fun_name(x: u32) -> u32 {
+    x * 2
+}",
+        );
+    }
+    #[test]
+    fn extract_return_stmt() {
+        check_assist(
+            extract_function,
+            r"
+fn foo() -> u32 {
+    $0return 2 + 2$0;
+}",
+            r"
+fn foo() -> u32 {
+    return fun_name();
+}
+fn $0fun_name() -> u32 {
+    2 + 2
+}",
+        );
+    }
+    #[test]
+    fn does_not_add_extra_whitespace() {
+        check_assist(
+            extract_function,
+            r"
+fn foo() -> u32 {
+    $0return 2 + 2$0;
+}",
+            r"
+fn foo() -> u32 {
+    return fun_name();
+}
+fn $0fun_name() -> u32 {
+    2 + 2
+}",
+        );
+    }
+    #[test]
+    fn break_stmt() {
+        check_assist(
+            extract_function,
+            r"
+fn main() {
+    let result = loop {
+        $0break 2 + 2$0;
+    };
+}",
+            r"
+fn main() {
+    let result = loop {
+        break fun_name();
+    };
+}
+fn $0fun_name() -> i32 {
+    2 + 2
+}",
+        );
+    }
+    #[test]
+    fn extract_cast() {
+        check_assist(
+            extract_function,
+            r"
+fn main() {
+    let v = $00f32 as u32$0;
+}",
+            r"
+fn main() {
+    let v = fun_name();
+}
+fn $0fun_name() -> u32 {
+    0f32 as u32
+}",
+        );
+    }
+    #[test]
+    fn return_not_applicable() {
+        check_assist_not_applicable(extract_function, r"fn foo() { $0return$0; } ");
+    }
+    #[test]
+    fn method_to_freestanding() {
+        check_assist(
+            extract_function,
+            r"
+struct S;
+impl S {
+    fn foo(&self) -> i32 {
+        $01+1$0
+    }
+}",
+            r"
+struct S;
+impl S {
+    fn foo(&self) -> i32 {
+        fun_name()
+    }
+}
+fn $0fun_name() -> i32 {
+    1+1
+}",
+        );
+    }
+    #[test]
+    fn method_with_reference() {
+        check_assist(
+            extract_function,
+            r"
+struct S { f: i32 };
+impl S {
+    fn foo(&self) -> i32 {
+        $01+self.f$0
+    }
+}",
+            r"
+struct S { f: i32 };
+impl S {
+    fn foo(&self) -> i32 {
+        self.fun_name()
+    }
+    fn $0fun_name(&self) -> i32 {
+        1+self.f
+    }
+}",
+        );
+    }
+    #[test]
+    fn method_with_mut() {
+        check_assist(
+            extract_function,
+            r"
+struct S { f: i32 };
+impl S {
+    fn foo(&mut self) {
+        $0self.f += 1;$0
+    }
+}",
+            r"
+struct S { f: i32 };
+impl S {
+    fn foo(&mut self) {
+        self.fun_name();
+    }
+    fn $0fun_name(&mut self) {
+        self.f += 1;
+    }
+}",
+        );
+    }
+    #[test]
+    fn variable_defined_inside_and_used_after_no_ret() {
+        check_assist(
+            extract_function,
+            r"
+fn foo() {
+    let n = 1;
+    $0let k = n * n;$0
+    let m = k + 1;
+}",
+            r"
+fn foo() {
+    let n = 1;
+    let k = fun_name(n);
+    let m = k + 1;
+}
+fn $0fun_name(n: i32) -> i32 {
+    let k = n * n;
+    k
+}",
+        );
+    }
+    #[test]
+    fn two_variables_defined_inside_and_used_after_no_ret() {
+        check_assist(
+            extract_function,
+            r"
+fn foo() {
+    let n = 1;
+    $0let k = n * n;
+    let m = k + 2;$0
+    let h = k + m;
+}",
+            r"
+fn foo() {
+    let n = 1;
+    let (k, m) = fun_name(n);
+    let h = k + m;
+}
+fn $0fun_name(n: i32) -> (i32, i32) {
+    let k = n * n;
+    let m = k + 2;
+    (k, m)
+}",
+        );
+    }
+    #[test]
+    fn nontrivial_patterns_define_variables() {
+        check_assist(
+            extract_function,
+            r"
+struct Counter(i32);
+fn foo() {
+    $0let Counter(n) = Counter(0);$0
+    let m = n;
+}",
+            r"
+struct Counter(i32);
+fn foo() {
+    let n = fun_name();
+    let m = n;
+}
+fn $0fun_name() -> i32 {
+    let Counter(n) = Counter(0);
+    n
+}",
+        );
+    }
+    #[test]
+    fn struct_with_two_fields_pattern_define_variables() {
+        check_assist(
+            extract_function,
+            r"
+struct Counter { n: i32, m: i32 };
+fn foo() {
+    $0let Counter { n, m: k } = Counter { n: 1, m: 2 };$0
+    let h = n + k;
+}",
+            r"
+struct Counter { n: i32, m: i32 };
+fn foo() {
+    let (n, k) = fun_name();
+    let h = n + k;
+}
+fn $0fun_name() -> (i32, i32) {
+    let Counter { n, m: k } = Counter { n: 1, m: 2 };
+    (n, k)
+}",
+        );
+    }
+    #[test]
+    fn mut_var_from_outer_scope() {
+        check_assist(
+            extract_function,
+            r"
+fn foo() {
+    let mut n = 1;
+    $0n += 1;$0
+    let m = n + 1;
+}",
+            r"
+fn foo() {
+    let mut n = 1;
+    fun_name(&mut n);
+    let m = n + 1;
+}
+fn $0fun_name(n: &mut i32) {
+    *n += 1;
+}",
+        );
+    }
+    #[test]
+    fn mut_field_from_outer_scope() {
+        check_assist(
+            extract_function,
+            r"
+struct C { n: i32 }
+fn foo() {
+    let mut c = C { n: 0 };
+    $0c.n += 1;$0
+    let m = c.n + 1;
+}",
+            r"
+struct C { n: i32 }
+fn foo() {
+    let mut c = C { n: 0 };
+    fun_name(&mut c);
+    let m = c.n + 1;
+}
+fn $0fun_name(c: &mut C) {
+    c.n += 1;
+}",
+        );
+    }
+    #[test]
+    fn mut_nested_field_from_outer_scope() {
+        check_assist(
+            extract_function,
+            r"
+struct P { n: i32}
+struct C { p: P }
+fn foo() {
+    let mut c = C { p: P { n: 0 } };
+    let mut v = C { p: P { n: 0 } };
+    let u = C { p: P { n: 0 } };
+    $0c.p.n += u.p.n;
+    let r = &mut v.p.n;$0
+    let m = c.p.n + v.p.n + u.p.n;
+}",
+            r"
+struct P { n: i32}
+struct C { p: P }
+fn foo() {
+    let mut c = C { p: P { n: 0 } };
+    let mut v = C { p: P { n: 0 } };
+    let u = C { p: P { n: 0 } };
+    fun_name(&mut c, &u, &mut v);
+    let m = c.p.n + v.p.n + u.p.n;
+}
+fn $0fun_name(c: &mut C, u: &C, v: &mut C) {
+    c.p.n += u.p.n;
+    let r = &mut v.p.n;
+}",
+        );
+    }
+    #[test]
+    fn mut_param_many_usages_stmt() {
+        check_assist(
+            extract_function,
+            r"
+fn bar(k: i32) {}
+trait I: Copy {
+    fn succ(&self) -> Self;
+    fn inc(&mut self) -> Self { let v = self.succ(); *self = v; v }
+}
+impl I for i32 {
+    fn succ(&self) -> Self { *self + 1 }
+}
+fn foo() {
+    let mut n = 1;
+    $0n += n;
+    bar(n);
+    bar(n+1);
+    bar(n*n);
+    bar(&n);
+    n.inc();
+    let v = &mut n;
+    *v = v.succ();
+    n.succ();$0
+    let m = n + 1;
+}",
+            r"
+fn bar(k: i32) {}
+trait I: Copy {
+    fn succ(&self) -> Self;
+    fn inc(&mut self) -> Self { let v = self.succ(); *self = v; v }
+}
+impl I for i32 {
+    fn succ(&self) -> Self { *self + 1 }
+}
+fn foo() {
+    let mut n = 1;
+    fun_name(&mut n);
+    let m = n + 1;
+}
+fn $0fun_name(n: &mut i32) {
+    *n += *n;
+    bar(*n);
+    bar(*n+1);
+    bar(*n**n);
+    bar(&*n);
+    n.inc();
+    let v = n;
+    *v = v.succ();
+    n.succ();
+}",
+        );
+    }
+    #[test]
+    fn mut_param_many_usages_expr() {
+        check_assist(
+            extract_function,
+            r"
+fn bar(k: i32) {}
+trait I: Copy {
+    fn succ(&self) -> Self;
+    fn inc(&mut self) -> Self { let v = self.succ(); *self = v; v }
+}
+impl I for i32 {
+    fn succ(&self) -> Self { *self + 1 }
+}
+fn foo() {
+    let mut n = 1;
+    $0{
+        n += n;
+        bar(n);
+        bar(n+1);
+        bar(n*n);
+        bar(&n);
+        n.inc();
+        let v = &mut n;
+        *v = v.succ();
+        n.succ();
+    }$0
+    let m = n + 1;
+}",
+            r"
+fn bar(k: i32) {}
+trait I: Copy {
+    fn succ(&self) -> Self;
+    fn inc(&mut self) -> Self { let v = self.succ(); *self = v; v }
+}
+impl I for i32 {
+    fn succ(&self) -> Self { *self + 1 }
+}
+fn foo() {
+    let mut n = 1;
+    fun_name(&mut n);
+    let m = n + 1;
+}
+fn $0fun_name(n: &mut i32) {
+    {
+        *n += *n;
+        bar(*n);
+        bar(*n+1);
+        bar(*n**n);
+        bar(&*n);
+        n.inc();
+        let v = n;
+        *v = v.succ();
+        n.succ();
+    }
+}",
+        );
+    }
+    #[test]
+    fn mut_param_by_value() {
+        check_assist(
+            extract_function,
+            r"
+fn foo() {
+    let mut n = 1;
+    $0n += 1;$0
+}",
+            r"
+fn foo() {
+    let mut n = 1;
+    fun_name(n);
+}
+fn $0fun_name(mut n: i32) {
+    n += 1;
+}",
+        );
+    }
+    #[test]
+    fn mut_param_because_of_mut_ref() {
+        check_assist(
+            extract_function,
+            r"
+fn foo() {
+    let mut n = 1;
+    $0let v = &mut n;
+    *v += 1;$0
+    let k = n;
+}",
+            r"
+fn foo() {
+    let mut n = 1;
+    fun_name(&mut n);
+    let k = n;
+}
+fn $0fun_name(n: &mut i32) {
+    let v = n;
+    *v += 1;
+}",
+        );
+    }
+    #[test]
+    fn mut_param_by_value_because_of_mut_ref() {
+        check_assist(
+            extract_function,
+            r"
+fn foo() {
+    let mut n = 1;
+    $0let v = &mut n;
+    *v += 1;$0
+}",
+            r"
+fn foo() {
+    let mut n = 1;
+    fun_name(n);
+}
+fn $0fun_name(mut n: i32) {
+    let v = &mut n;
+    *v += 1;
+}",
+        );
+    }
+    #[test]
+    fn mut_method_call() {
+        check_assist(
+            extract_function,
+            r"
+trait I {
+    fn inc(&mut self);
+}
+impl I for i32 {
+    fn inc(&mut self) { *self += 1 }
+}
+fn foo() {
+    let mut n = 1;
+    $0n.inc();$0
+}",
+            r"
+trait I {
+    fn inc(&mut self);
+}
+impl I for i32 {
+    fn inc(&mut self) { *self += 1 }
+}
+fn foo() {
+    let mut n = 1;
+    fun_name(n);
+}
+fn $0fun_name(mut n: i32) {
+    n.inc();
+}",
+        );
+    }
+    #[test]
+    fn shared_method_call() {
+        check_assist(
+            extract_function,
+            r"
+trait I {
+    fn succ(&self);
+}
+impl I for i32 {
+    fn succ(&self) { *self + 1 }
+}
+fn foo() {
+    let mut n = 1;
+    $0n.succ();$0
+}",
+            r"
+trait I {
+    fn succ(&self);
+}
+impl I for i32 {
+    fn succ(&self) { *self + 1 }
+}
+fn foo() {
+    let mut n = 1;
+    fun_name(n);
+}
+fn $0fun_name(n: i32) {
+    n.succ();
+}",
+        );
+    }
+    #[test]
+    fn mut_method_call_with_other_receiver() {
+        check_assist(
+            extract_function,
+            r"
+trait I {
+    fn inc(&mut self, n: i32);
+}
+impl I for i32 {
+    fn inc(&mut self, n: i32) { *self += n }
+}
+fn foo() {
+    let mut n = 1;
+    $0let mut m = 2;
+    m.inc(n);$0
+}",
+            r"
+trait I {
+    fn inc(&mut self, n: i32);
+}
+impl I for i32 {
+    fn inc(&mut self, n: i32) { *self += n }
+}
+fn foo() {
+    let mut n = 1;
+    fun_name(n);
+}
+fn $0fun_name(n: i32) {
+    let mut m = 2;
+    m.inc(n);
+}",
+        );
+    }
+    #[test]
+    fn non_copy_without_usages_after() {
+        check_assist(
+            extract_function,
+            r"
+struct Counter(i32);
+fn foo() {
+    let c = Counter(0);
+    $0let n = c.0;$0
+}",
+            r"
+struct Counter(i32);
+fn foo() {
+    let c = Counter(0);
+    fun_name(c);
+}
+fn $0fun_name(c: Counter) {
+    let n = c.0;
+}",
+        );
+    }
+    #[test]
+    fn non_copy_used_after() {
+        check_assist(
+            extract_function,
+            r"
+struct Counter(i32);
+fn foo() {
+    let c = Counter(0);
+    $0let n = c.0;$0
+    let m = c.0;
+}",
+            r"
+struct Counter(i32);
+fn foo() {
+    let c = Counter(0);
+    fun_name(&c);
+    let m = c.0;
+}
+fn $0fun_name(c: &Counter) {
+    let n = c.0;
+}",
+        );
+    }
+    #[test]
+    fn indented_stmts() {
+        check_assist(
+            extract_function,
+            r"
+fn foo() {
+    if true {
+        loop {
+            $0let n = 1;
+            let m = 2;$0
+        }
+    }
+}",
+            r"
+fn foo() {
+    if true {
+        loop {
+            fun_name();
+        }
+    }
+}
+fn $0fun_name() {
+    let n = 1;
+    let m = 2;
+}",
+        );
+    }
+    #[test]
+    fn indented_stmts_inside_mod() {
+        check_assist(
+            extract_function,
+            r"
+mod bar {
+    fn foo() {
+        if true {
+            loop {
+                $0let n = 1;
+                let m = 2;$0
+            }
+        }
+    }
+}",
+            r"
+mod bar {
+    fn foo() {
+        if true {
+            loop {
+                fun_name();
+            }
+        }
+    }
+    fn $0fun_name() {
+        let n = 1;
+        let m = 2;
+    }
+}",
+        );
+    }
+}
diff --git a/crates/assists/src/handlers/extract_struct_from_enum_variant.rs b/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
index e3ef04932..5c7678b53 100644
--- a/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
+++ b/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
@@ -151,8 +151,8 @@ fn insert_import(
        ctx.config.insert_use.prefix_kind,
    );
    if let Some(mut mod_path) = mod_path {
-        mod_path.segments.pop();
+        mod_path.pop_segment();
-        mod_path.segments.push(variant_hir_name.clone());
+        mod_path.push_segment(variant_hir_name.clone());
        let scope = ImportScope::find_insert_use_container(scope_node, &ctx.sema)?;
        *rewriter += insert_use(&scope, mod_path_to_ast(&mod_path), ctx.config.insert_use.merge);
    }
diff --git a/crates/assists/src/handlers/generate_enum_match_method.rs b/crates/assists/src/handlers/generate_enum_match_method.rs
new file mode 100644
index 000000000..ee89d4208
--- /dev/null
+++ b/crates/assists/src/handlers/generate_enum_match_method.rs
@@ -0,0 +1,221 @@
+use stdx::{format_to, to_lower_snake_case};
+use syntax::ast::{self, AstNode, NameOwner};
+use syntax::{ast::VisibilityOwner, T};
+use test_utils::mark;
+use crate::{utils::find_struct_impl, AssistContext, AssistId, AssistKind, Assists};
+// Assist: generate_enum_match_method
+//
+// Generate an `is_` method for an enum variant.
+//
+// ```
+// enum Version {
+//  Undefined,
+//  Minor$0,
+//  Major,
+// }
+// ```
+// ->
+// ```
+// enum Version {
+//  Undefined,
+//  Minor,
+//  Major,
+// }
+//
+// impl Version {
+//     /// Returns `true` if the version is [`Minor`].
+//     fn is_minor(&self) -> bool {
+//         matches!(self, Self::Minor)
+//     }
+// }
+// ```
+pub(crate) fn generate_enum_match_method(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let variant = ctx.find_node_at_offset::<ast::Variant>()?;
+    let variant_name = variant.name()?;
+    let parent_enum = variant.parent_enum();
+    if !matches!(variant.kind(), ast::StructKind::Unit) {
+        mark::hit!(test_gen_enum_match_on_non_unit_variant_not_implemented);
+        return None;
+    }
+    let enum_lowercase_name = to_lower_snake_case(&parent_enum.name()?.to_string());
+    let fn_name = to_lower_snake_case(&variant_name.to_string());
+    // Return early if we've found an existing new fn
+    let impl_def = find_struct_impl(
+        &ctx,
+        &ast::AdtDef::Enum(parent_enum.clone()),
+        format!("is_{}", fn_name).as_str(),
+    )?;
+    let target = variant.syntax().text_range();
+    acc.add(
+        AssistId("generate_enum_match_method", AssistKind::Generate),
+        "Generate an `is_` method for an enum variant",
+        target,
+        |builder| {
+            let mut buf = String::with_capacity(512);
+            if impl_def.is_some() {
+                buf.push('\n');
+            }
+            let vis = parent_enum.visibility().map_or(String::new(), |v| format!("{} ", v));
+            format_to!(
+                buf,
+                "    /// Returns `true` if the {} is [`{}`].
+    {}fn is_{}(&self) -> bool {{
+        matches!(self, Self::{})
+    }}",
+                enum_lowercase_name,
+                variant_name,
+                vis,
+                fn_name,
+                variant_name
+            );
+            let start_offset = impl_def
+                .and_then(|impl_def| {
+                    buf.push('\n');
+                    let start = impl_def
+                        .syntax()
+                        .descendants_with_tokens()
+                        .find(|t| t.kind() == T!['{'])?
+                        .text_range()
+                        .end();
+                    Some(start)
+                })
+                .unwrap_or_else(|| {
+                    buf = generate_impl_text(&parent_enum, &buf);
+                    parent_enum.syntax().text_range().end()
+                });
+            builder.insert(start_offset, buf);
+        },
+    )
+}
+// Generates the surrounding `impl Type { <code> }` including type and lifetime
+// parameters
+fn generate_impl_text(strukt: &ast::Enum, code: &str) -> String {
+    let mut buf = String::with_capacity(code.len());
+    buf.push_str("\n\nimpl ");
+    buf.push_str(strukt.name().unwrap().text());
+    format_to!(buf, " {{\n{}\n}}", code);
+    buf
+}
+#[cfg(test)]
+mod tests {
+    use test_utils::mark;
+    use crate::tests::{check_assist, check_assist_not_applicable};
+    use super::*;
+    fn check_not_applicable(ra_fixture: &str) {
+        check_assist_not_applicable(generate_enum_match_method, ra_fixture)
+    }
+    #[test]
+    fn test_generate_enum_match_from_variant() {
+        check_assist(
+            generate_enum_match_method,
+            r#"
+enum Variant {
+    Undefined,
+    Minor$0,
+    Major,
+}"#,
+            r#"enum Variant {
+    Undefined,
+    Minor,
+    Major,
+}
+impl Variant {
+    /// Returns `true` if the variant is [`Minor`].
+    fn is_minor(&self) -> bool {
+        matches!(self, Self::Minor)
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn test_generate_enum_match_already_implemented() {
+        check_not_applicable(
+            r#"
+enum Variant {
+    Undefined,
+    Minor$0,
+    Major,
+}
+impl Variant {
+    fn is_minor(&self) -> bool {
+        matches!(self, Self::Minor)
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn test_add_from_impl_no_element() {
+        mark::check!(test_gen_enum_match_on_non_unit_variant_not_implemented);
+        check_not_applicable(
+            r#"
+enum Variant {
+    Undefined,
+    Minor(u32)$0,
+    Major,
+}"#,
+        );
+    }
+    #[test]
+    fn test_generate_enum_match_from_variant_with_one_variant() {
+        check_assist(
+            generate_enum_match_method,
+            r#"enum Variant { Undefi$0ned }"#,
+            r#"
+enum Variant { Undefined }
+impl Variant {
+    /// Returns `true` if the variant is [`Undefined`].
+    fn is_undefined(&self) -> bool {
+        matches!(self, Self::Undefined)
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn test_generate_enum_match_from_variant_with_visibility_marker() {
+        check_assist(
+            generate_enum_match_method,
+            r#"
+pub(crate) enum Variant {
+    Undefined,
+    Minor$0,
+    Major,
+}"#,
+            r#"pub(crate) enum Variant {
+    Undefined,
+    Minor,
+    Major,
+}
+impl Variant {
+    /// Returns `true` if the variant is [`Minor`].
+    pub(crate) fn is_minor(&self) -> bool {
+        matches!(self, Self::Minor)
+    }
+}"#,
+        );
+    }
+}
diff --git a/crates/assists/src/handlers/generate_new.rs b/crates/assists/src/handlers/generate_new.rs
index b7390855a..84832273f 100644
--- a/crates/assists/src/handlers/generate_new.rs
+++ b/crates/assists/src/handlers/generate_new.rs
@@ -1,4 +1,3 @@
-use hir::Adt;
 use itertools::Itertools;
 use stdx::format_to;
 use syntax::{
@@ -6,7 +5,7 @@ use syntax::{
    SmolStr, T,
 };
-use crate::{AssistContext, AssistId, AssistKind, Assists};
+use crate::{utils::find_struct_impl, AssistContext, AssistId, AssistKind, Assists};
 // Assist: generate_new
 //
@@ -38,7 +37,7 @@ pub(crate) fn generate_new(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
    };
    // Return early if we've found an existing new fn
-    let impl_def = find_struct_impl(&ctx, &strukt)?;
+    let impl_def = find_struct_impl(&ctx, &ast::AdtDef::Struct(strukt.clone()), "new")?;
    let target = strukt.syntax().text_range();
    acc.add(AssistId("generate_new", AssistKind::Generate), "Generate `new`", target, |builder| {
@@ -111,65 +110,6 @@ fn generate_impl_text(strukt: &ast::Struct, code: &str) -> String {
    buf
 }
-// Uses a syntax-driven approach to find any impl blocks for the struct that
-// exist within the module/file
-//
-// Returns `None` if we've found an existing `new` fn
-//
-// FIXME: change the new fn checking to a more semantic approach when that's more
-// viable (e.g. we process proc macros, etc)
-fn find_struct_impl(ctx: &AssistContext, strukt: &ast::Struct) -> Option<Option<ast::Impl>> {
-    let db = ctx.db();
-    let module = strukt.syntax().ancestors().find(|node| {
-        ast::Module::can_cast(node.kind()) || ast::SourceFile::can_cast(node.kind())
-    })?;
-    let struct_def = ctx.sema.to_def(strukt)?;
-    let block = module.descendants().filter_map(ast::Impl::cast).find_map(|impl_blk| {
-        let blk = ctx.sema.to_def(&impl_blk)?;
-        // FIXME: handle e.g. `struct S<T>; impl<U> S<U> {}`
-        // (we currently use the wrong type parameter)
-        // also we wouldn't want to use e.g. `impl S<u32>`
-        let same_ty = match blk.target_ty(db).as_adt() {
-            Some(def) => def == Adt::Struct(struct_def),
-            None => false,
-        };
-        let not_trait_impl = blk.target_trait(db).is_none();
-        if !(same_ty && not_trait_impl) {
-            None
-        } else {
-            Some(impl_blk)
-        }
-    });
-    if let Some(ref impl_blk) = block {
-        if has_new_fn(impl_blk) {
-            return None;
-        }
-    }
-    Some(block)
-}
-fn has_new_fn(imp: &ast::Impl) -> bool {
-    if let Some(il) = imp.assoc_item_list() {
-        for item in il.assoc_items() {
-            if let ast::AssocItem::Fn(f) = item {
-                if let Some(name) = f.name() {
-                    if name.text().eq_ignore_ascii_case("new") {
-                        return true;
-                    }
-                }
-            }
-        }
-    }
-    false
-}
 #[cfg(test)]
 mod tests {
    use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
diff --git a/crates/assists/src/lib.rs b/crates/assists/src/lib.rs
index 559b9651e..83fbf6986 100644
--- a/crates/assists/src/lib.rs
+++ b/crates/assists/src/lib.rs
@@ -117,6 +117,7 @@ mod handlers {
    mod convert_integer_literal;
    mod early_return;
    mod expand_glob_import;
+    mod extract_function;
    mod extract_struct_from_enum_variant;
    mod extract_variable;
    mod fill_match_arms;
@@ -126,6 +127,7 @@ mod handlers {
    mod flip_trait_bound;
    mod generate_default_from_enum_variant;
    mod generate_derive;
+    mod generate_enum_match_method;
    mod generate_from_impl_for_enum;
    mod generate_function;
    mod generate_impl;
@@ -174,6 +176,7 @@ mod handlers {
            early_return::convert_to_guarded_return,
            expand_glob_import::expand_glob_import,
            move_module_to_file::move_module_to_file,
+            extract_function::extract_function,
            extract_struct_from_enum_variant::extract_struct_from_enum_variant,
            extract_variable::extract_variable,
            fill_match_arms::fill_match_arms,
@@ -183,6 +186,7 @@ mod handlers {
            flip_trait_bound::flip_trait_bound,
            generate_default_from_enum_variant::generate_default_from_enum_variant,
            generate_derive::generate_derive,
+            generate_enum_match_method::generate_enum_match_method,
            generate_from_impl_for_enum::generate_from_impl_for_enum,
            generate_function::generate_function,
            generate_impl::generate_impl,
diff --git a/crates/assists/src/tests/generated.rs b/crates/assists/src/tests/generated.rs
index 9aa807f10..0dbb05f2a 100644
--- a/crates/assists/src/tests/generated.rs
+++ b/crates/assists/src/tests/generated.rs
@@ -257,6 +257,33 @@ fn qux(bar: Bar, baz: Baz) {}
 }
 #[test]
+fn doctest_extract_function() {
+    check_doc_test(
+        "extract_function",
+        r#####"
+fn main() {
+    let n = 1;
+    $0let m = n + 2;
+    let k = m + n;$0
+    let g = 3;
+}
+"#####,
+        r#####"
+fn main() {
+    let n = 1;
+    fun_name(n);
+    let g = 3;
+}
+fn $0fun_name(n: i32) {
+    let m = n + 2;
+    let k = m + n;
+}
+"#####,
+    )
+}
+#[test]
 fn doctest_extract_struct_from_enum_variant() {
    check_doc_test(
        "extract_struct_from_enum_variant",
@@ -433,6 +460,34 @@ struct Point {
 }
 #[test]
+fn doctest_generate_enum_match_method() {
+    check_doc_test(
+        "generate_enum_match_method",
+        r#####"
+enum Version {
+ Undefined,
+ Minor$0,
+ Major,
+}
+"#####,
+        r#####"
+enum Version {
+ Undefined,
+ Minor,
+ Major,
+}
+impl Version {
+    /// Returns `true` if the version is [`Minor`].
+    fn is_minor(&self) -> bool {
+        matches!(self, Self::Minor)
+    }
+}
+"#####,
+    )
+}
+#[test]
 fn doctest_generate_from_impl_for_enum() {
    check_doc_test(
        "generate_from_impl_for_enum",
diff --git a/crates/assists/src/utils.rs b/crates/assists/src/utils.rs
index 4e762e18b..3842558d8 100644
--- a/crates/assists/src/utils.rs
+++ b/crates/assists/src/utils.rs
@@ -2,7 +2,7 @@
 use std::ops;
-use hir::HasSource;
+use hir::{Adt, HasSource};
 use ide_db::{helpers::SnippetCap, RootDatabase};
 use itertools::Itertools;
 use syntax::{
@@ -15,7 +15,10 @@ use syntax::{
    SyntaxNode, TextSize, T,
 };
-use crate::ast_transform::{self, AstTransform, QualifyPaths, SubstituteTypeParams};
+use crate::{
+    assist_context::AssistContext,
+    ast_transform::{self, AstTransform, QualifyPaths, SubstituteTypeParams},
+};
 pub(crate) fn unwrap_trivial_block(block: ast::BlockExpr) -> ast::Expr {
    extract_trivial_expression(&block)
@@ -267,3 +270,71 @@ pub(crate) fn does_pat_match_variant(pat: &ast::Pat, var: &ast::Pat) -> bool {
    pat_head == var_head
 }
+// Uses a syntax-driven approach to find any impl blocks for the struct that
+// exist within the module/file
+//
+// Returns `None` if we've found an existing `new` fn
+//
+// FIXME: change the new fn checking to a more semantic approach when that's more
+// viable (e.g. we process proc macros, etc)
+pub(crate) fn find_struct_impl(
+    ctx: &AssistContext,
+    strukt: &ast::AdtDef,
+    name: &str,
+) -> Option<Option<ast::Impl>> {
+    let db = ctx.db();
+    let module = strukt.syntax().ancestors().find(|node| {
+        ast::Module::can_cast(node.kind()) || ast::SourceFile::can_cast(node.kind())
+    })?;
+    let struct_def = match strukt {
+        ast::AdtDef::Enum(e) => Adt::Enum(ctx.sema.to_def(e)?),
+        ast::AdtDef::Struct(s) => Adt::Struct(ctx.sema.to_def(s)?),
+        ast::AdtDef::Union(u) => Adt::Union(ctx.sema.to_def(u)?),
+    };
+    let block = module.descendants().filter_map(ast::Impl::cast).find_map(|impl_blk| {
+        let blk = ctx.sema.to_def(&impl_blk)?;
+        // FIXME: handle e.g. `struct S<T>; impl<U> S<U> {}`
+        // (we currently use the wrong type parameter)
+        // also we wouldn't want to use e.g. `impl S<u32>`
+        let same_ty = match blk.target_ty(db).as_adt() {
+            Some(def) => def == struct_def,
+            None => false,
+        };
+        let not_trait_impl = blk.target_trait(db).is_none();
+        if !(same_ty && not_trait_impl) {
+            None
+        } else {
+            Some(impl_blk)
+        }
+    });
+    if let Some(ref impl_blk) = block {
+        if has_fn(impl_blk, name) {
+            return None;
+        }
+    }
+    Some(block)
+}
+fn has_fn(imp: &ast::Impl, rhs_name: &str) -> bool {
+    if let Some(il) = imp.assoc_item_list() {
+        for item in il.assoc_items() {
+            if let ast::AssocItem::Fn(f) = item {
+                if let Some(name) = f.name() {
+                    if name.text().eq_ignore_ascii_case(rhs_name) {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+    false
+}
diff --git a/crates/completion/src/completions/flyimport.rs b/crates/completion/src/completions/flyimport.rs
index 9c6a5a40c..c9f928483 100644
--- a/crates/completion/src/completions/flyimport.rs
+++ b/crates/completion/src/completions/flyimport.rs
@@ -175,7 +175,7 @@ fn compute_fuzzy_completion_order_key(
    user_input_lowercased: &str,
 ) -> usize {
    mark::hit!(certain_fuzzy_order_test);
-    let proposed_import_name = match proposed_mod_path.segments.last() {
+    let proposed_import_name = match proposed_mod_path.segments().last() {
        Some(name) => name.to_string().to_lowercase(),
        None => return usize::MAX,
    };
diff --git a/crates/completion/src/completions/unqualified_path.rs b/crates/completion/src/completions/unqualified_path.rs
index 5d62fab97..e2482f959 100644
--- a/crates/completion/src/completions/unqualified_path.rs
+++ b/crates/completion/src/completions/unqualified_path.rs
@@ -63,7 +63,7 @@ fn complete_enum_variants(acc: &mut Completions, ctx: &CompletionContext, ty: &T
            if let Some(path) = module.find_use_path(ctx.db, ModuleDef::from(variant)) {
                // Variants with trivial paths are already added by the existing completion logic,
                // so we should avoid adding these twice
-                if path.segments.len() > 1 {
+                if path.segments().len() > 1 {
                    acc.add_qualified_enum_variant(ctx, variant, path);
                }
            }
diff --git a/crates/completion/src/item.rs b/crates/completion/src/item.rs
index 8ec4ac65e..884711f11 100644
--- a/crates/completion/src/item.rs
+++ b/crates/completion/src/item.rs
@@ -332,9 +332,9 @@ impl Builder {
                label = format!("{} ({})", label, import_to_add.import_path);
            } else {
                let mut import_path_without_last_segment = import_to_add.import_path.to_owned();
-                let _ = import_path_without_last_segment.segments.pop();
+                let _ = import_path_without_last_segment.pop_segment();
-                if !import_path_without_last_segment.segments.is_empty() {
+                if !import_path_without_last_segment.segments().is_empty() {
                    lookup = lookup.or_else(|| Some(label.clone()));
                    insert_text = insert_text.or_else(|| Some(label.clone()));
                    label = format!("{}::{}", import_path_without_last_segment, label);
diff --git a/crates/completion/src/render.rs b/crates/completion/src/render.rs
index e11b881ca..eddaaa6f3 100644
--- a/crates/completion/src/render.rs
+++ b/crates/completion/src/render.rs
@@ -57,7 +57,7 @@ pub(crate) fn render_resolution_with_import<'a>(
        ScopeDef::ModuleDef(ModuleDef::Function(f)) => f.name(ctx.completion.db).to_string(),
        ScopeDef::ModuleDef(ModuleDef::Const(c)) => c.name(ctx.completion.db)?.to_string(),
        ScopeDef::ModuleDef(ModuleDef::TypeAlias(t)) => t.name(ctx.completion.db).to_string(),
-        _ => import_edit.import_path.segments.last()?.to_string(),
+        _ => import_edit.import_path.segments().last()?.to_string(),
    };
    Render::new(ctx).render_resolution(local_name, Some(import_edit), resolution).map(|mut item| {
        item.completion_kind = CompletionKind::Magic;
diff --git a/crates/completion/src/render/enum_variant.rs b/crates/completion/src/render/enum_variant.rs
index adcddebd1..9214193b4 100644
--- a/crates/completion/src/render/enum_variant.rs
+++ b/crates/completion/src/render/enum_variant.rs
@@ -45,8 +45,8 @@ impl<'a> EnumRender<'a> {
        let (qualified_name, short_qualified_name) = match &path {
            Some(path) => {
                let full = path.to_string();
-                let short =
+                let segments = path.segments();
-                    path.segments[path.segments.len().saturating_sub(2)..].iter().join("::");
+                let short = segments[segments.len().saturating_sub(2)..].iter().join("::");
                (full, short)
            }
            None => (name.to_string(), name.to_string()),
diff --git a/crates/hir_def/src/adt.rs b/crates/hir_def/src/adt.rs
index 06f0b9b18..ed36c3109 100644
--- a/crates/hir_def/src/adt.rs
+++ b/crates/hir_def/src/adt.rs
@@ -351,7 +351,7 @@ fn lower_field(
 ) -> FieldData {
    FieldData {
        name: field.name.clone(),
-        type_ref: field.type_ref.clone(),
+        type_ref: item_tree[field.type_ref].clone(),
        visibility: item_tree[override_visibility.unwrap_or(field.visibility)].clone(),
    }
 }
diff --git a/crates/hir_def/src/body.rs b/crates/hir_def/src/body.rs
index b9ecf22fa..9a432f7d1 100644
--- a/crates/hir_def/src/body.rs
+++ b/crates/hir_def/src/body.rs
@@ -33,7 +33,7 @@ use crate::{
    nameres::DefMap,
    path::{ModPath, Path},
    src::HasSource,
-    AsMacroCall, DefWithBodyId, HasModule, Lookup, ModuleId,
+    AsMacroCall, DefWithBodyId, HasModule, LocalModuleId, Lookup, ModuleId,
 };
 /// A subset of Expander that only deals with cfg attributes. We only need it to
@@ -46,10 +46,10 @@ pub(crate) struct CfgExpander {
 pub(crate) struct Expander {
    cfg_expander: CfgExpander,
-    crate_def_map: Arc<DefMap>,
+    def_map: Arc<DefMap>,
    current_file_id: HirFileId,
    ast_id_map: Arc<AstIdMap>,
-    module: ModuleId,
+    module: LocalModuleId,
    recursion_limit: usize,
 }
@@ -91,10 +91,10 @@ impl Expander {
        let ast_id_map = db.ast_id_map(current_file_id);
        Expander {
            cfg_expander,
-            crate_def_map,
+            def_map: crate_def_map,
            current_file_id,
            ast_id_map,
-            module,
+            module: module.local_id,
            recursion_limit: 0,
        }
    }
@@ -102,7 +102,6 @@ impl Expander {
    pub(crate) fn enter_expand<T: ast::AstNode>(
        &mut self,
        db: &dyn DefDatabase,
-        local_scope: Option<&ItemScope>,
        macro_call: ast::MacroCall,
    ) -> ExpandResult<Option<(Mark, T)>> {
        if self.recursion_limit + 1 > EXPANSION_RECURSION_LIMIT {
@@ -112,18 +111,12 @@ impl Expander {
        let macro_call = InFile::new(self.current_file_id, &macro_call);
-        let resolver = |path: ModPath| -> Option<MacroDefId> {
+        let resolver =
-            if let Some(local_scope) = local_scope {
+            |path: ModPath| -> Option<MacroDefId> { self.resolve_path_as_macro(db, &path) };
-                if let Some(def) = path.as_ident().and_then(|n| local_scope.get_legacy_macro(n)) {
-                    return Some(def);
-                }
-            }
-            self.resolve_path_as_macro(db, &path)
-        };
        let mut err = None;
        let call_id =
-            macro_call.as_call_id_with_errors(db, self.crate_def_map.krate(), resolver, &mut |e| {
+            macro_call.as_call_id_with_errors(db, self.def_map.krate(), resolver, &mut |e| {
                err.get_or_insert(e);
            });
        let call_id = match call_id {
@@ -204,10 +197,7 @@ impl Expander {
    }
    fn resolve_path_as_macro(&self, db: &dyn DefDatabase, path: &ModPath) -> Option<MacroDefId> {
-        self.crate_def_map
+        self.def_map.resolve_path(db, self.module, path, BuiltinShadowMode::Other).0.take_macros()
-            .resolve_path(db, self.module.local_id, path, BuiltinShadowMode::Other)
-            .0
-            .take_macros()
    }
    fn ast_id<N: AstNode>(&self, item: &N) -> AstId<N> {
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index 209965fca..28b11cdde 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -1,7 +1,7 @@
 //! Transforms `ast::Expr` into an equivalent `hir_def::expr::Expr`
 //! representation.
-use std::{any::type_name, sync::Arc};
+use std::{any::type_name, mem, sync::Arc};
 use either::Either;
 use hir_expand::{
@@ -36,8 +36,8 @@ use crate::{
    item_tree::{ItemTree, ItemTreeId, ItemTreeNode},
    path::{GenericArgs, Path},
    type_ref::{Mutability, Rawness, TypeRef},
-    AdtId, ConstLoc, ContainerId, DefWithBodyId, EnumLoc, FunctionLoc, Intern, ModuleDefId,
+    AdtId, BlockLoc, ConstLoc, ContainerId, DefWithBodyId, EnumLoc, FunctionLoc, Intern,
-    StaticLoc, StructLoc, TraitLoc, TypeAliasLoc, UnionLoc,
+    ModuleDefId, StaticLoc, StructLoc, TraitLoc, TypeAliasLoc, UnionLoc,
 };
 use super::{diagnostics::BodyDiagnostic, ExprSource, PatSource};
@@ -152,8 +152,8 @@ impl ExprCollector<'_> {
    fn alloc_expr_desugared(&mut self, expr: Expr) -> ExprId {
        self.make_expr(expr, Err(SyntheticSyntax))
    }
-    fn empty_block(&mut self) -> ExprId {
+    fn unit(&mut self) -> ExprId {
-        self.alloc_expr_desugared(Expr::Block { statements: Vec::new(), tail: None, label: None })
+        self.alloc_expr_desugared(Expr::Tuple { exprs: Vec::new() })
    }
    fn missing_expr(&mut self) -> ExprId {
        self.alloc_expr_desugared(Expr::Missing)
@@ -222,7 +222,7 @@ impl ExprCollector<'_> {
                                MatchArm { pat, expr: then_branch, guard: None },
                                MatchArm {
                                    pat: placeholder_pat,
-                                    expr: else_branch.unwrap_or_else(|| self.empty_block()),
+                                    expr: else_branch.unwrap_or_else(|| self.unit()),
                                    guard: None,
                                },
                            ];
@@ -561,7 +561,7 @@ impl ExprCollector<'_> {
        let outer_file = self.expander.current_file_id;
        let macro_call = self.expander.to_source(AstPtr::new(&e));
-        let res = self.expander.enter_expand(self.db, Some(&self.body.item_scope), e);
+        let res = self.expander.enter_expand(self.db, e);
        match &res.err {
            Some(ExpandError::UnresolvedProcMacro) => {
@@ -697,12 +697,30 @@ impl ExprCollector<'_> {
    }
    fn collect_block(&mut self, block: ast::BlockExpr) -> ExprId {
-        let syntax_node_ptr = AstPtr::new(&block.clone().into());
+        let ast_id = self.expander.ast_id(&block);
+        let block_loc =
+            BlockLoc { ast_id, module: self.expander.def_map.module_id(self.expander.module) };
+        let block_id = self.db.intern_block(block_loc);
+        let opt_def_map = self.db.block_def_map(block_id);
+        let has_def_map = opt_def_map.is_some();
+        let def_map = opt_def_map.unwrap_or_else(|| self.expander.def_map.clone());
+        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);
        self.collect_stmts_items(block.statements());
        let statements =
            block.statements().filter_map(|s| self.collect_stmt(s)).flatten().collect();
        let tail = block.tail_expr().map(|e| self.collect_expr(e));
-        self.alloc_expr(Expr::Block { statements, tail, label: None }, syntax_node_ptr)
+        let syntax_node_ptr = AstPtr::new(&block.clone().into());
+        let expr_id = self.alloc_expr(
+            Expr::Block { id: block_id, statements, tail, label: None },
+            syntax_node_ptr,
+        );
+        self.expander.def_map = prev_def_map;
+        self.expander.module = prev_local_module;
+        expr_id
    }
    fn collect_stmts_items(&mut self, stmts: ast::AstChildren<ast::Stmt>) {
@@ -794,7 +812,7 @@ impl ExprCollector<'_> {
                }
                Either::Right(e) => {
                    let mac = MacroDefId {
-                        krate: self.expander.module.krate,
+                        krate: self.expander.def_map.krate(),
                        ast_id: Some(self.expander.ast_id(&e)),
                        kind: MacroDefKind::Declarative,
                        local_inner: false,
@@ -832,9 +850,9 @@ impl ExprCollector<'_> {
                if annotation == BindingAnnotation::Unannotated && subpat.is_none() {
                    // This could also be a single-segment path pattern. To
                    // decide that, we need to try resolving the name.
-                    let (resolved, _) = self.expander.crate_def_map.resolve_path(
+                    let (resolved, _) = self.expander.def_map.resolve_path(
                        self.db,
-                        self.expander.module.local_id,
+                        self.expander.module,
                        &name.clone().into(),
                        BuiltinShadowMode::Other,
                    );
diff --git a/crates/hir_def/src/body/tests.rs b/crates/hir_def/src/body/tests.rs
index 2e5d0a01e..a92134ba7 100644
--- a/crates/hir_def/src/body/tests.rs
+++ b/crates/hir_def/src/body/tests.rs
@@ -1,7 +1,10 @@
-use base_db::{fixture::WithFixture, SourceDatabase};
+mod block;
+use base_db::{fixture::WithFixture, FilePosition, SourceDatabase};
+use expect_test::Expect;
 use test_utils::mark;
-use crate::{test_db::TestDB, ModuleDefId};
+use crate::{test_db::TestDB, BlockId, ModuleDefId};
 use super::*;
@@ -31,6 +34,114 @@ fn check_diagnostics(ra_fixture: &str) {
    db.check_diagnostics();
 }
+fn block_def_map_at(ra_fixture: &str) -> String {
+    let (db, position) = crate::test_db::TestDB::with_position(ra_fixture);
+    let krate = db.crate_graph().iter().next().unwrap();
+    let def_map = db.crate_def_map(krate);
+    let mut block =
+        block_at_pos(&db, &def_map, position).expect("couldn't find enclosing function or block");
+    loop {
+        let def_map = db.block_def_map(block).unwrap_or_else(|| def_map.clone());
+        let new_block = block_at_pos(&db, &def_map, position);
+        match new_block {
+            Some(new_block) => {
+                assert_ne!(block, new_block);
+                block = new_block;
+            }
+            None => {
+                return def_map.dump(&db);
+            }
+        }
+    }
+}
+fn block_at_pos(db: &dyn DefDatabase, def_map: &DefMap, position: FilePosition) -> Option<BlockId> {
+    // Find the smallest (innermost) function containing the cursor.
+    let mut size = None;
+    let mut fn_def = None;
+    for (_, module) in def_map.modules() {
+        let file_id = module.definition_source(db).file_id;
+        if file_id != position.file_id.into() {
+            continue;
+        }
+        let root = db.parse_or_expand(file_id).unwrap();
+        let ast_map = db.ast_id_map(file_id);
+        let item_tree = db.item_tree(file_id);
+        for decl in module.scope.declarations() {
+            if let ModuleDefId::FunctionId(it) = decl {
+                let ast = ast_map.get(item_tree[it.lookup(db).id.value].ast_id).to_node(&root);
+                let range = ast.syntax().text_range();
+                if !range.contains(position.offset) {
+                    continue;
+                }
+                let new_size = match size {
+                    None => range.len(),
+                    Some(size) => {
+                        if range.len() < size {
+                            range.len()
+                        } else {
+                            size
+                        }
+                    }
+                };
+                if size != Some(new_size) {
+                    size = Some(new_size);
+                    fn_def = Some(it);
+                }
+            }
+        }
+    }
+    let (body, source_map) = db.body_with_source_map(fn_def?.into());
+    // Now find the smallest encompassing block expression in the function body.
+    let mut size = None;
+    let mut block_id = None;
+    for (expr_id, expr) in body.exprs.iter() {
+        if let Expr::Block { id, .. } = expr {
+            if let Ok(ast) = source_map.expr_syntax(expr_id) {
+                if ast.file_id != position.file_id.into() {
+                    continue;
+                }
+                let root = db.parse_or_expand(ast.file_id).unwrap();
+                let ast = ast.value.to_node(&root);
+                let range = ast.syntax().text_range();
+                if !range.contains(position.offset) {
+                    continue;
+                }
+                let new_size = match size {
+                    None => range.len(),
+                    Some(size) => {
+                        if range.len() < size {
+                            range.len()
+                        } else {
+                            size
+                        }
+                    }
+                };
+                if size != Some(new_size) {
+                    size = Some(new_size);
+                    block_id = Some(*id);
+                }
+            }
+        }
+    }
+    Some(block_id.expect("can't find block containing cursor"))
+}
+fn check_at(ra_fixture: &str, expect: Expect) {
+    let actual = block_def_map_at(ra_fixture);
+    expect.assert_eq(&actual);
+}
 #[test]
 fn your_stack_belongs_to_me() {
    mark::check!(your_stack_belongs_to_me);
diff --git a/crates/hir_def/src/nameres/tests/block.rs b/crates/hir_def/src/body/tests/block.rs
index 6cc659513..062560a70 100644
--- a/crates/hir_def/src/nameres/tests/block.rs
+++ b/crates/hir_def/src/body/tests/block.rs
@@ -1,4 +1,5 @@
 use super::*;
+use expect_test::expect;
 #[test]
 fn inner_item_smoke() {
@@ -13,6 +14,7 @@ fn outer() {
        expect![[r#"
            block scope
            inner: v
            crate
            inner: t
            outer: v
@@ -37,6 +39,7 @@ fn outer() {
            CrateStruct: t v
            SelfStruct: t v
            Struct: t v
            crate
            Struct: t v
            outer: v
@@ -61,6 +64,7 @@ fn outer() {
            block scope
            imported: t v
            name: v
            crate
            name: t
            outer: v
@@ -87,9 +91,11 @@ fn outer() {
            inner1: t
            inner2: v
            outer: v
            block scope
            inner: v
            inner1: t
            crate
            outer: v
        "#]],
@@ -112,6 +118,7 @@ struct Struct {}
        expect![[r#"
            block scope
            Struct: t
            crate
            Struct: t
            module: t
@@ -142,6 +149,7 @@ fn f() {
        expect![[r#"
            block scope
            Hit: t
            crate
            f: v
        "#]],
@@ -176,11 +184,47 @@ pub mod mark {
        expect![[r#"
            block scope
            Hit: t
            block scope
            nested: v
            crate
            f: v
            mark: t
        "#]],
    );
 }
+#[test]
+fn macro_resolve_legacy() {
+    check_at(
+        r#"
+//- /lib.rs
+mod module;
+//- /module.rs
+macro_rules! m {
+    () => {
+        struct Def {}
+    };
+}
+fn f() {
+    {
+        m!();
+        $0
+    }
+}
+        "#,
+        expect![[r#"
+            block scope
+            Def: t
+            crate
+            module: t
+            crate::module
+            f: v
+        "#]],
+    )
+}
diff --git a/crates/hir_def/src/data.rs b/crates/hir_def/src/data.rs
index e7b7724f7..42fcca386 100644
--- a/crates/hir_def/src/data.rs
+++ b/crates/hir_def/src/data.rs
@@ -41,8 +41,8 @@ impl FunctionData {
        Arc::new(FunctionData {
            name: func.name.clone(),
-            params: func.params.to_vec(),
+            params: func.params.iter().map(|id| item_tree[*id].clone()).collect(),
-            ret_type: func.ret_type.clone(),
+            ret_type: item_tree[func.ret_type].clone(),
            attrs: item_tree.attrs(db, krate, ModItem::from(loc.id.value).into()).clone(),
            has_self_param: func.has_self_param,
            has_body: func.has_body,
@@ -75,7 +75,7 @@ impl TypeAliasData {
        Arc::new(TypeAliasData {
            name: typ.name.clone(),
-            type_ref: typ.type_ref.clone(),
+            type_ref: typ.type_ref.map(|id| item_tree[id].clone()),
            visibility: item_tree[typ.visibility].clone(),
            is_extern: typ.is_extern,
            bounds: typ.bounds.to_vec(),
@@ -144,8 +144,8 @@ impl ImplData {
        let item_tree = db.item_tree(impl_loc.id.file_id);
        let impl_def = &item_tree[impl_loc.id.value];
-        let target_trait = impl_def.target_trait.clone();
+        let target_trait = impl_def.target_trait.map(|id| item_tree[id].clone());
-        let target_type = impl_def.target_type.clone();
+        let target_type = item_tree[impl_def.target_type].clone();
        let is_negative = impl_def.is_negative;
        let module_id = impl_loc.container.module(db);
        let container = AssocContainerId::ImplId(id);
@@ -182,7 +182,7 @@ impl ConstData {
        Arc::new(ConstData {
            name: konst.name.clone(),
-            type_ref: konst.type_ref.clone(),
+            type_ref: item_tree[konst.type_ref].clone(),
            visibility: item_tree[konst.visibility].clone(),
        })
    }
@@ -205,7 +205,7 @@ impl StaticData {
        Arc::new(StaticData {
            name: Some(statik.name.clone()),
-            type_ref: statik.type_ref.clone(),
+            type_ref: item_tree[statik.type_ref].clone(),
            visibility: item_tree[statik.visibility].clone(),
            mutable: statik.mutable,
            is_extern: statik.is_extern,
@@ -262,7 +262,7 @@ fn collect_items(
                let root = db.parse_or_expand(file_id).unwrap();
                let call = ast_id_map.get(call.ast_id).to_node(&root);
-                if let Some((mark, mac)) = expander.enter_expand(db, None, call).value {
+                if let Some((mark, mac)) = expander.enter_expand(db, call).value {
                    let src: InFile<ast::MacroItems> = expander.to_source(mac);
                    let item_tree = db.item_tree(src.file_id);
                    let iter =
diff --git a/crates/hir_def/src/db.rs b/crates/hir_def/src/db.rs
index aef7e1f6c..6c01f1ed0 100644
--- a/crates/hir_def/src/db.rs
+++ b/crates/hir_def/src/db.rs
@@ -58,8 +58,23 @@ pub trait DefDatabase: InternDatabase + AstDatabase + Upcast<dyn AstDatabase> {
    #[salsa::invoke(DefMap::crate_def_map_query)]
    fn crate_def_map_query(&self, krate: CrateId) -> Arc<DefMap>;
+    /// Computes the block-level `DefMap`, returning `None` when `block` doesn't contain any inner
+    /// items directly.
+    ///
+    /// For example:
+    ///
+    /// ```
+    /// fn f() { // (0)
+    ///     { // (1)
+    ///         fn inner() {}
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// The `block_def_map` for block 0 would return `None`, while `block_def_map` of block 1 would
+    /// return a `DefMap` containing `inner`.
    #[salsa::invoke(DefMap::block_def_map_query)]
-    fn block_def_map(&self, block: BlockId) -> Arc<DefMap>;
+    fn block_def_map(&self, block: BlockId) -> Option<Arc<DefMap>>;
    #[salsa::invoke(StructData::struct_data_query)]
    fn struct_data(&self, id: StructId) -> Arc<StructData>;
diff --git a/crates/hir_def/src/expr.rs b/crates/hir_def/src/expr.rs
index 5be838f4a..4d72eaeaf 100644
--- a/crates/hir_def/src/expr.rs
+++ b/crates/hir_def/src/expr.rs
@@ -20,6 +20,7 @@ use crate::{
    builtin_type::{BuiltinFloat, BuiltinInt},
    path::{GenericArgs, Path},
    type_ref::{Mutability, Rawness, TypeRef},
+    BlockId,
 };
 pub type ExprId = Idx<Expr>;
@@ -56,6 +57,7 @@ pub enum Expr {
        else_branch: Option<ExprId>,
    },
    Block {
+        id: BlockId,
        statements: Vec<Statement>,
        tail: Option<ExprId>,
        label: Option<LabelId>,
diff --git a/crates/hir_def/src/find_path.rs b/crates/hir_def/src/find_path.rs
index 94a1d567d..aa2c6e04e 100644
--- a/crates/hir_def/src/find_path.rs
+++ b/crates/hir_def/src/find_path.rs
@@ -36,13 +36,13 @@ const MAX_PATH_LEN: usize = 15;
 impl ModPath {
    fn starts_with_std(&self) -> bool {
-        self.segments.first() == Some(&known::std)
+        self.segments().first() == Some(&known::std)
    }
    // When std library is present, paths starting with `std::`
    // should be preferred over paths starting with `core::` and `alloc::`
    fn can_start_with_std(&self) -> bool {
-        let first_segment = self.segments.first();
+        let first_segment = self.segments().first();
        first_segment == Some(&known::alloc) || first_segment == Some(&known::core)
    }
 }
@@ -157,7 +157,7 @@ fn find_path_inner(
    if let Some(ModuleDefId::EnumVariantId(variant)) = item.as_module_def_id() {
        if let Some(mut path) = find_path(db, ItemInNs::Types(variant.parent.into()), from) {
            let data = db.enum_data(variant.parent);
-            path.segments.push(data.variants[variant.local_id].name.clone());
+            path.push_segment(data.variants[variant.local_id].name.clone());
            return Some(path);
        }
        // If this doesn't work, it seems we have no way of referring to the
@@ -186,7 +186,7 @@ fn find_path_inner(
                best_path_len - 1,
                prefixed,
            ) {
-                path.segments.push(name);
+                path.push_segment(name);
                let new_path = if let Some(best_path) = best_path {
                    select_best_path(best_path, path, prefer_no_std)
@@ -215,7 +215,7 @@ fn find_path_inner(
                    prefixed,
                )?;
                mark::hit!(partially_imported);
-                path.segments.push(info.path.segments.last().unwrap().clone());
+                path.push_segment(info.path.segments.last().unwrap().clone());
                Some(path)
            })
        });
diff --git a/crates/hir_def/src/item_scope.rs b/crates/hir_def/src/item_scope.rs
index 2750e1c91..ee46c3330 100644
--- a/crates/hir_def/src/item_scope.rs
+++ b/crates/hir_def/src/item_scope.rs
@@ -8,6 +8,7 @@ use hir_expand::name::Name;
 use hir_expand::MacroDefKind;
 use once_cell::sync::Lazy;
 use rustc_hash::{FxHashMap, FxHashSet};
+use stdx::format_to;
 use test_utils::mark;
 use crate::{
@@ -292,6 +293,30 @@ impl ItemScope {
            *vis = Visibility::Module(this_module);
        }
    }
+    pub(crate) fn dump(&self, buf: &mut String) {
+        let mut entries: Vec<_> = self.resolutions().collect();
+        entries.sort_by_key(|(name, _)| name.clone());
+        for (name, def) in entries {
+            format_to!(buf, "{}:", name.map_or("_".to_string(), |name| name.to_string()));
+            if def.types.is_some() {
+                buf.push_str(" t");
+            }
+            if def.values.is_some() {
+                buf.push_str(" v");
+            }
+            if def.macros.is_some() {
+                buf.push_str(" m");
+            }
+            if def.is_none() {
+                buf.push_str(" _");
+            }
+            buf.push('\n');
+        }
+    }
 }
 impl PerNs {
diff --git a/crates/hir_def/src/item_tree.rs b/crates/hir_def/src/item_tree.rs
index 42d9f0947..3233b1957 100644
--- a/crates/hir_def/src/item_tree.rs
+++ b/crates/hir_def/src/item_tree.rs
@@ -24,7 +24,7 @@ use la_arena::{Arena, Idx, RawIdx};
 use profile::Count;
 use rustc_hash::FxHashMap;
 use smallvec::SmallVec;
-use syntax::{ast, match_ast};
+use syntax::{ast, match_ast, SyntaxKind};
 use test_utils::mark;
 use crate::{
@@ -80,6 +80,10 @@ impl ItemTree {
    pub(crate) fn item_tree_query(db: &dyn DefDatabase, file_id: HirFileId) -> Arc<ItemTree> {
        let _p = profile::span("item_tree_query").detail(|| format!("{:?}", file_id));
        let syntax = if let Some(node) = db.parse_or_expand(file_id) {
+            if node.kind() == SyntaxKind::ERROR {
+                // FIXME: not 100% sure why these crop up, but return an empty tree to avoid a panic
+                return Default::default();
+            }
            node
        } else {
            return Default::default();
@@ -142,6 +146,7 @@ impl ItemTree {
                macro_defs,
                vis,
                generics,
+                type_refs,
                inner_items,
            } = &mut **data;
@@ -165,6 +170,8 @@ impl ItemTree {
            vis.arena.shrink_to_fit();
            generics.arena.shrink_to_fit();
+            type_refs.arena.shrink_to_fit();
+            type_refs.map.shrink_to_fit();
            inner_items.shrink_to_fit();
        }
@@ -233,7 +240,7 @@ impl ItemVisibilities {
    fn alloc(&mut self, vis: RawVisibility) -> RawVisibilityId {
        match &vis {
            RawVisibility::Public => RawVisibilityId::PUB,
-            RawVisibility::Module(path) if path.segments.is_empty() => match &path.kind {
+            RawVisibility::Module(path) if path.segments().is_empty() => match &path.kind {
                PathKind::Super(0) => RawVisibilityId::PRIV,
                PathKind::Crate => RawVisibilityId::PUB_CRATE,
                _ => RawVisibilityId(self.arena.alloc(vis).into_raw().into()),
@@ -244,10 +251,8 @@ impl ItemVisibilities {
 }
 static VIS_PUB: RawVisibility = RawVisibility::Public;
-static VIS_PRIV: RawVisibility =
+static VIS_PRIV: RawVisibility = RawVisibility::Module(ModPath::from_kind(PathKind::Super(0)));
-    RawVisibility::Module(ModPath { kind: PathKind::Super(0), segments: Vec::new() });
+static VIS_PUB_CRATE: RawVisibility = RawVisibility::Module(ModPath::from_kind(PathKind::Crate));
-static VIS_PUB_CRATE: RawVisibility =
-    RawVisibility::Module(ModPath { kind: PathKind::Crate, segments: Vec::new() });
 #[derive(Default, Debug, Eq, PartialEq)]
 struct GenericParamsStorage {
@@ -275,6 +280,32 @@ static EMPTY_GENERICS: GenericParams = GenericParams {
    where_predicates: Vec::new(),
 };
+/// `TypeRef` interner.
+#[derive(Default, Debug, Eq, PartialEq)]
+struct TypeRefStorage {
+    arena: Arena<Arc<TypeRef>>,
+    map: FxHashMap<Arc<TypeRef>, Idx<Arc<TypeRef>>>,
+}
+impl TypeRefStorage {
+    // Note: We lie about the `Idx<TypeRef>` to hide the interner details.
+    fn intern(&mut self, ty: TypeRef) -> Idx<TypeRef> {
+        if let Some(id) = self.map.get(&ty) {
+            return Idx::from_raw(id.into_raw());
+        }
+        let ty = Arc::new(ty);
+        let idx = self.arena.alloc(ty.clone());
+        self.map.insert(ty, idx);
+        Idx::from_raw(idx.into_raw())
+    }
+    fn lookup(&self, id: Idx<TypeRef>) -> &TypeRef {
+        &self.arena[Idx::from_raw(id.into_raw())]
+    }
+}
 #[derive(Default, Debug, Eq, PartialEq)]
 struct ItemTreeData {
    imports: Arena<Import>,
@@ -297,6 +328,7 @@ struct ItemTreeData {
    vis: ItemVisibilities,
    generics: GenericParamsStorage,
+    type_refs: TypeRefStorage,
    inner_items: FxHashMap<FileAstId<ast::BlockExpr>, SmallVec<[ModItem; 1]>>,
 }
@@ -485,6 +517,14 @@ impl Index<GenericParamsId> for ItemTree {
    }
 }
+impl Index<Idx<TypeRef>> for ItemTree {
+    type Output = TypeRef;
+    fn index(&self, id: Idx<TypeRef>) -> &Self::Output {
+        self.data().type_refs.lookup(id)
+    }
+}
 impl<N: ItemTreeNode> Index<FileItemTreeId<N>> for ItemTree {
    type Output = N;
    fn index(&self, id: FileItemTreeId<N>) -> &N {
@@ -528,9 +568,9 @@ pub struct Function {
    /// Whether the function is located in an `extern` block (*not* whether it is an
    /// `extern "abi" fn`).
    pub is_extern: bool,
-    pub params: Box<[TypeRef]>,
+    pub params: Box<[Idx<TypeRef>]>,
    pub is_varargs: bool,
-    pub ret_type: TypeRef,
+    pub ret_type: Idx<TypeRef>,
    pub ast_id: FileAstId<ast::Fn>,
 }
@@ -577,7 +617,7 @@ pub struct Const {
    /// const _: () = ();
    pub name: Option<Name>,
    pub visibility: RawVisibilityId,
-    pub type_ref: TypeRef,
+    pub type_ref: Idx<TypeRef>,
    pub ast_id: FileAstId<ast::Const>,
 }
@@ -588,7 +628,7 @@ pub struct Static {
    pub mutable: bool,
    /// Whether the static is in an `extern` block.
    pub is_extern: bool,
-    pub type_ref: TypeRef,
+    pub type_ref: Idx<TypeRef>,
    pub ast_id: FileAstId<ast::Static>,
 }
@@ -605,8 +645,8 @@ pub struct Trait {
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct Impl {
    pub generic_params: GenericParamsId,
-    pub target_trait: Option<TypeRef>,
+    pub target_trait: Option<Idx<TypeRef>>,
-    pub target_type: TypeRef,
+    pub target_type: Idx<TypeRef>,
    pub is_negative: bool,
    pub items: Box<[AssocItem]>,
    pub ast_id: FileAstId<ast::Impl>,
@@ -619,7 +659,7 @@ pub struct TypeAlias {
    /// Bounds on the type alias itself. Only valid in trait declarations, eg. `type Assoc: Copy;`.
    pub bounds: Box<[TypeBound]>,
    pub generic_params: GenericParamsId,
-    pub type_ref: Option<TypeRef>,
+    pub type_ref: Option<Idx<TypeRef>>,
    pub is_extern: bool,
    pub ast_id: FileAstId<ast::TypeAlias>,
 }
@@ -802,6 +842,6 @@ pub enum Fields {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Field {
    pub name: Name,
-    pub type_ref: TypeRef,
+    pub type_ref: Idx<TypeRef>,
    pub visibility: RawVisibilityId,
 }
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index acc001add..8f2f0b340 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -183,6 +183,7 @@ impl Ctx {
                                block_stack.push(self.source_ast_id_map.ast_id(&block));
                            },
                            ast::Item(item) => {
+                                // FIXME: This triggers for macro calls in expression position
                                let mod_items = self.lower_mod_item(&item, true);
                                let current_block = block_stack.last();
                                if let (Some(mod_items), Some(block)) = (mod_items, current_block) {
@@ -363,6 +364,7 @@ impl Ctx {
                params.push(type_ref);
            }
        }
+        let params = params.into_iter().map(|param| self.data().type_refs.intern(param)).collect();
        let mut is_varargs = false;
        if let Some(params) = func.param_list() {
@@ -384,6 +386,8 @@ impl Ctx {
            ret_type
        };
+        let ret_type = self.data().type_refs.intern(ret_type);
        let has_body = func.body().is_some();
        let ast_id = self.source_ast_id_map.ast_id(func);
@@ -395,7 +399,7 @@ impl Ctx {
            has_body,
            is_unsafe: func.unsafe_token().is_some(),
            is_extern: false,
-            params: params.into_boxed_slice(),
+            params,
            is_varargs,
            ret_type,
            ast_id,
@@ -656,6 +660,7 @@ impl Ctx {
                generics.fill(&self.body_ctx, sm, node);
                // lower `impl Trait` in arguments
                for param in &*func.params {
+                    let param = self.data().type_refs.lookup(*param);
                    generics.fill_implicit_impl_trait_args(param);
                }
            }
@@ -708,11 +713,15 @@ impl Ctx {
        self.data().vis.alloc(vis)
    }
-    fn lower_type_ref(&self, type_ref: &ast::Type) -> TypeRef {
+    fn lower_type_ref(&mut self, type_ref: &ast::Type) -> Idx<TypeRef> {
-        TypeRef::from_ast(&self.body_ctx, type_ref.clone())
+        let tyref = TypeRef::from_ast(&self.body_ctx, type_ref.clone());
+        self.data().type_refs.intern(tyref)
    }
-    fn lower_type_ref_opt(&self, type_ref: Option<ast::Type>) -> TypeRef {
+    fn lower_type_ref_opt(&mut self, type_ref: Option<ast::Type>) -> Idx<TypeRef> {
-        type_ref.map(|ty| self.lower_type_ref(&ty)).unwrap_or(TypeRef::Error)
+        match type_ref.map(|ty| self.lower_type_ref(&ty)) {
+            Some(it) => it,
+            None => self.data().type_refs.intern(TypeRef::Error),
+        }
    }
    /// Forces the visibility `vis` to be used for all items lowered during execution of `f`.
@@ -741,7 +750,8 @@ impl Ctx {
 fn desugar_future_path(orig: TypeRef) -> Path {
    let path = path![core::future::Future];
-    let mut generic_args: Vec<_> = std::iter::repeat(None).take(path.segments.len() - 1).collect();
+    let mut generic_args: Vec<_> =
+        std::iter::repeat(None).take(path.segments().len() - 1).collect();
    let mut last = GenericArgs::empty();
    let binding =
        AssociatedTypeBinding { name: name![Output], type_ref: Some(orig), bounds: Vec::new() };
diff --git a/crates/hir_def/src/lib.rs b/crates/hir_def/src/lib.rs
index 42b50b5b7..b50923747 100644
--- a/crates/hir_def/src/lib.rs
+++ b/crates/hir_def/src/lib.rs
@@ -81,7 +81,13 @@ pub struct ModuleId {
 impl ModuleId {
    pub fn def_map(&self, db: &dyn db::DefDatabase) -> Arc<DefMap> {
        match self.block {
-            Some(block) => db.block_def_map(block),
+            Some(block) => {
+                db.block_def_map(block).unwrap_or_else(|| {
+                    // NOTE: This should be unreachable - all `ModuleId`s come from their `DefMap`s,
+                    // so the `DefMap` here must exist.
+                    panic!("no `block_def_map` for `ModuleId` {:?}", self);
+                })
+            }
            None => db.crate_def_map(self.krate),
        }
    }
@@ -239,6 +245,7 @@ pub struct BlockId(salsa::InternId);
 #[derive(Debug, Hash, PartialEq, Eq, Clone)]
 pub struct BlockLoc {
    ast_id: AstId<ast::BlockExpr>,
+    /// The containing module.
    module: ModuleId,
 }
 impl_intern!(BlockId, BlockLoc, intern_block, lookup_intern_block);
@@ -655,7 +662,7 @@ impl AsMacroCall for AstIdWithPath<ast::Item> {
            def.as_lazy_macro(
                db.upcast(),
                krate,
-                MacroCallKind::Attr(self.ast_id, self.path.segments.last()?.to_string()),
+                MacroCallKind::Attr(self.ast_id, self.path.segments().last()?.to_string()),
            )
            .into(),
        )
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index 0a15fc470..ad2e9bcac 100644
--- a/crates/hir_def/src/nameres.rs
+++ b/crates/hir_def/src/nameres.rs
@@ -73,7 +73,15 @@ use crate::{
    AstId, BlockId, BlockLoc, LocalModuleId, ModuleDefId, ModuleId,
 };
-/// Contains all top-level defs from a macro-expanded crate
+/// Contains the results of (early) name resolution.
+///
+/// A `DefMap` stores the module tree and the definitions that are in scope in every module after
+/// item-level macros have been expanded.
+///
+/// Every crate has a primary `DefMap` whose root is the crate's main file (`main.rs`/`lib.rs`),
+/// computed by the `crate_def_map` query. Additionally, every block expression introduces the
+/// opportunity to write arbitrary item and module hierarchies, and thus gets its own `DefMap` that
+/// is computed by the `block_def_map` query.
 #[derive(Debug, PartialEq, Eq)]
 pub struct DefMap {
    _c: Count<Self>,
@@ -91,11 +99,13 @@ pub struct DefMap {
    diagnostics: Vec<DefDiagnostic>,
 }
-#[derive(Debug, PartialEq, Eq)]
+/// For `DefMap`s computed for a block expression, this stores its location in the parent map.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
 struct BlockInfo {
+    /// The `BlockId` this `DefMap` was created from.
    block: BlockId,
-    parent: Arc<DefMap>,
+    /// The containing module.
-    parent_module: LocalModuleId,
+    parent: ModuleId,
 }
 impl std::ops::Index<LocalModuleId> for DefMap {
@@ -197,21 +207,25 @@ impl DefMap {
        Arc::new(def_map)
    }
-    pub(crate) fn block_def_map_query(db: &dyn DefDatabase, block_id: BlockId) -> Arc<DefMap> {
+    pub(crate) fn block_def_map_query(
+        db: &dyn DefDatabase,
+        block_id: BlockId,
+    ) -> Option<Arc<DefMap>> {
        let block: BlockLoc = db.lookup_intern_block(block_id);
-        let parent = block.module.def_map(db);
-        // FIXME: It would be good to just return the parent map when the block has no items, but
+        let item_tree = db.item_tree(block.ast_id.file_id);
-        // we rely on `def_map.block` in a few places, which is `Some` for the inner `DefMap`.
+        if item_tree.inner_items_of_block(block.ast_id.value).is_empty() {
+            return None;
+        }
-        let block_info =
+        let block_info = BlockInfo { block: block_id, parent: block.module };
-            BlockInfo { block: block_id, parent, parent_module: block.module.local_id };
-        let mut def_map = DefMap::empty(block.module.krate, block_info.parent.edition);
+        let parent_map = block.module.def_map(db);
+        let mut def_map = DefMap::empty(block.module.krate, parent_map.edition);
        def_map.block = Some(block_info);
        let def_map = collector::collect_defs(db, def_map, Some(block.ast_id));
-        Arc::new(def_map)
+        Some(Arc::new(def_map))
    }
    fn empty(krate: CrateId, edition: Edition) -> DefMap {
@@ -275,9 +289,15 @@ impl DefMap {
        ModuleId { krate: self.krate, local_id, block }
    }
-    pub(crate) fn crate_root(&self) -> ModuleId {
+    pub(crate) fn crate_root(&self, db: &dyn DefDatabase) -> ModuleId {
-        let (root_map, _) = self.ancestor_maps(self.root).last().unwrap();
+        self.with_ancestor_maps(db, self.root, &mut |def_map, _module| {
-        root_map.module_id(root_map.root)
+            if def_map.block.is_none() {
+                Some(def_map.module_id(def_map.root))
+            } else {
+                None
+            }
+        })
+        .expect("DefMap chain without root")
    }
    pub(crate) fn resolve_path(
@@ -292,25 +312,42 @@ impl DefMap {
        (res.resolved_def, res.segment_index)
    }
-    /// Iterates over the containing `DefMap`s, if `self` is a `DefMap` corresponding to a block
+    /// Ascends the `DefMap` hierarchy and calls `f` with every `DefMap` and containing module.
-    /// expression.
+    ///
-    fn ancestor_maps(
+    /// If `f` returns `Some(val)`, iteration is stopped and `Some(val)` is returned. If `f` returns
+    /// `None`, iteration continues.
+    fn with_ancestor_maps<T>(
        &self,
+        db: &dyn DefDatabase,
        local_mod: LocalModuleId,
-    ) -> impl Iterator<Item = (&DefMap, LocalModuleId)> {
+        f: &mut dyn FnMut(&DefMap, LocalModuleId) -> Option<T>,
-        std::iter::successors(Some((self, local_mod)), |(map, _)| {
+    ) -> Option<T> {
-            map.block.as_ref().map(|block| (&*block.parent, block.parent_module))
+        if let Some(it) = f(self, local_mod) {
-        })
+            return Some(it);
+        }
+        let mut block = self.block;
+        while let Some(block_info) = block {
+            let parent = block_info.parent.def_map(db);
+            if let Some(it) = f(&parent, block_info.parent.local_id) {
+                return Some(it);
+            }
+            block = parent.block;
+        }
+        None
    }
    // FIXME: this can use some more human-readable format (ideally, an IR
    // even), as this should be a great debugging aid.
-    pub fn dump(&self) -> String {
+    pub fn dump(&self, db: &dyn DefDatabase) -> String {
        let mut buf = String::new();
+        let mut arc;
        let mut current_map = self;
        while let Some(block) = &current_map.block {
            go(&mut buf, current_map, "block scope", current_map.root);
-            current_map = &*block.parent;
+            buf.push('\n');
+            arc = block.parent.def_map(db);
+            current_map = &*arc;
        }
        go(&mut buf, current_map, "crate", current_map.root);
        return buf;
@@ -318,27 +355,7 @@ impl DefMap {
        fn go(buf: &mut String, map: &DefMap, path: &str, module: LocalModuleId) {
            format_to!(buf, "{}\n", path);
-            let mut entries: Vec<_> = map.modules[module].scope.resolutions().collect();
+            map.modules[module].scope.dump(buf);
-            entries.sort_by_key(|(name, _)| name.clone());
-            for (name, def) in entries {
-                format_to!(buf, "{}:", name.map_or("_".to_string(), |name| name.to_string()));
-                if def.types.is_some() {
-                    buf.push_str(" t");
-                }
-                if def.values.is_some() {
-                    buf.push_str(" v");
-                }
-                if def.macros.is_some() {
-                    buf.push_str(" m");
-                }
-                if def.is_none() {
-                    buf.push_str(" _");
-                }
-                buf.push('\n');
-            }
            for (name, child) in map.modules[module].children.iter() {
                let path = format!("{}::{}", path, name);
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 6e86cc4a7..6bd41bc08 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -655,7 +655,7 @@ impl DefCollector<'_> {
                }
            }
        } else {
-            match import.path.segments.last() {
+            match import.path.segments().last() {
                Some(last_segment) => {
                    let name = match &import.alias {
                        Some(ImportAlias::Alias(name)) => Some(name.clone()),
@@ -956,7 +956,7 @@ impl DefCollector<'_> {
                let item_tree = self.db.item_tree(import.file_id);
                let import_data = &item_tree[import.value];
-                match (import_data.path.segments.first(), &import_data.path.kind) {
+                match (import_data.path.segments().first(), &import_data.path.kind) {
                    (Some(krate), PathKind::Plain) | (Some(krate), PathKind::Abs) => {
                        if diagnosed_extern_crates.contains(krate) {
                            continue;
@@ -1449,10 +1449,11 @@ impl ModCollector<'_, '_> {
        if let Some(macro_call_id) =
            ast_id.as_call_id(self.def_collector.db, self.def_collector.def_map.krate, |path| {
                path.as_ident().and_then(|name| {
-                    self.def_collector
+                    self.def_collector.def_map.with_ancestor_maps(
-                        .def_map
+                        self.def_collector.db,
-                        .ancestor_maps(self.module_id)
+                        self.module_id,
-                        .find_map(|(map, module)| map[module].scope.get_legacy_macro(&name))
+                        &mut |map, module| map[module].scope.get_legacy_macro(&name),
+                    )
                })
            })
        {
diff --git a/crates/hir_def/src/nameres/path_resolution.rs b/crates/hir_def/src/nameres/path_resolution.rs
index ecf75c777..036e389b0 100644
--- a/crates/hir_def/src/nameres/path_resolution.rs
+++ b/crates/hir_def/src/nameres/path_resolution.rs
@@ -108,8 +108,8 @@ impl DefMap {
        shadow: BuiltinShadowMode,
    ) -> ResolvePathResult {
        let mut result = ResolvePathResult::empty(ReachedFixedPoint::No);
-        result.segment_index = Some(usize::max_value());
+        let mut arc;
        let mut current_map = self;
        loop {
            let new = current_map.resolve_path_fp_with_macro_single(
@@ -127,12 +127,17 @@ impl DefMap {
            }
            // FIXME: this doesn't seem right; what if the different namespace resolutions come from different crates?
            result.krate = result.krate.or(new.krate);
-            result.segment_index = result.segment_index.min(new.segment_index);
+            result.segment_index = match (result.segment_index, new.segment_index) {
+                (Some(idx), None) => Some(idx),
+                (Some(old), Some(new)) => Some(old.max(new)),
+                (None, new) => new,
+            };
            match &current_map.block {
                Some(block) => {
-                    current_map = &block.parent;
+                    original_module = block.parent.local_id;
-                    original_module = block.parent_module;
+                    arc = block.parent.def_map(db);
+                    current_map = &*arc;
                }
                None => return result,
            }
@@ -147,12 +152,12 @@ impl DefMap {
        path: &ModPath,
        shadow: BuiltinShadowMode,
    ) -> ResolvePathResult {
-        let mut segments = path.segments.iter().enumerate();
+        let mut segments = path.segments().iter().enumerate();
        let mut curr_per_ns: PerNs = match path.kind {
            PathKind::DollarCrate(krate) => {
                if krate == self.krate {
                    mark::hit!(macro_dollar_crate_self);
-                    PerNs::types(self.crate_root().into(), Visibility::Public)
+                    PerNs::types(self.crate_root(db).into(), Visibility::Public)
                } else {
                    let def_map = db.crate_def_map(krate);
                    let module = def_map.module_id(def_map.root);
@@ -160,7 +165,7 @@ impl DefMap {
                    PerNs::types(module.into(), Visibility::Public)
                }
            }
-            PathKind::Crate => PerNs::types(self.crate_root().into(), Visibility::Public),
+            PathKind::Crate => PerNs::types(self.crate_root(db).into(), Visibility::Public),
            // plain import or absolute path in 2015: crate-relative with
            // fallback to extern prelude (with the simplification in
            // rust-lang/rust#57745)
@@ -188,7 +193,7 @@ impl DefMap {
                // BuiltinShadowMode wasn't Module, then we need to try
                // resolving it as a builtin.
                let prefer_module =
-                    if path.segments.len() == 1 { shadow } else { BuiltinShadowMode::Module };
+                    if path.segments().len() == 1 { shadow } else { BuiltinShadowMode::Module };
                log::debug!("resolving {:?} in module", segment);
                self.resolve_name_in_module(db, original_module, &segment, prefer_module)
@@ -201,15 +206,15 @@ impl DefMap {
                        None => match &self.block {
                            Some(block) => {
                                // Look up remaining path in parent `DefMap`
-                                let new_path = ModPath {
+                                let new_path = ModPath::from_segments(
-                                    kind: PathKind::Super(lvl - i),
+                                    PathKind::Super(lvl - i),
-                                    segments: path.segments.clone(),
+                                    path.segments().to_vec(),
-                                };
+                                );
                                log::debug!("`super` path: {} -> {} in parent map", path, new_path);
-                                return block.parent.resolve_path_fp_with_macro(
+                                return block.parent.def_map(db).resolve_path_fp_with_macro(
                                    db,
                                    mode,
-                                    block.parent_module,
+                                    block.parent.local_id,
                                    &new_path,
                                    shadow,
                                );
@@ -256,10 +261,10 @@ impl DefMap {
            curr_per_ns = match curr {
                ModuleDefId::ModuleId(module) => {
                    if module.krate != self.krate {
-                        let path = ModPath {
+                        let path = ModPath::from_segments(
-                            segments: path.segments[i..].to_vec(),
+                            PathKind::Super(0),
-                            kind: PathKind::Super(0),
+                            path.segments()[i..].iter().cloned(),
-                        };
+                        );
                        log::debug!("resolving {:?} in other crate", path);
                        let defp_map = module.def_map(db);
                        let (def, s) = defp_map.resolve_path(db, module.local_id, &path, shadow);
diff --git a/crates/hir_def/src/nameres/tests.rs b/crates/hir_def/src/nameres/tests.rs
index b36d0b59b..bd3e2701b 100644
--- a/crates/hir_def/src/nameres/tests.rs
+++ b/crates/hir_def/src/nameres/tests.rs
@@ -4,16 +4,16 @@ mod macros;
 mod mod_resolution;
 mod diagnostics;
 mod primitives;
-mod block;
 use std::sync::Arc;
-use base_db::{fixture::WithFixture, FilePosition, SourceDatabase};
+use base_db::{fixture::WithFixture, SourceDatabase};
 use expect_test::{expect, Expect};
-use syntax::AstNode;
 use test_utils::mark;
-use crate::{db::DefDatabase, nameres::*, test_db::TestDB, Lookup};
+use crate::{db::DefDatabase, test_db::TestDB};
+use super::DefMap;
 fn compute_crate_def_map(ra_fixture: &str) -> Arc<DefMap> {
    let db = TestDB::with_files(ra_fixture);
@@ -21,71 +21,14 @@ fn compute_crate_def_map(ra_fixture: &str) -> Arc<DefMap> {
    db.crate_def_map(krate)
 }
-fn compute_block_def_map(ra_fixture: &str) -> Arc<DefMap> {
+fn render_crate_def_map(ra_fixture: &str) -> String {
-    let (db, position) = TestDB::with_position(ra_fixture);
+    let db = TestDB::with_files(ra_fixture);
+    let krate = db.crate_graph().iter().next().unwrap();
-    // FIXME: perhaps we should make this use body lowering tests instead?
+    db.crate_def_map(krate).dump(&db)
-    let module = db.module_for_file(position.file_id);
-    let mut def_map = db.crate_def_map(module.krate);
-    while let Some(new_def_map) = descend_def_map_at_position(&db, position, def_map.clone()) {
-        def_map = new_def_map;
-    }
-    // FIXME: select the right module, not the root
-    def_map
-}
-fn descend_def_map_at_position(
-    db: &dyn DefDatabase,
-    position: FilePosition,
-    def_map: Arc<DefMap>,
-) -> Option<Arc<DefMap>> {
-    for (local_id, module_data) in def_map.modules() {
-        let mod_def = module_data.origin.definition_source(db);
-        let ast_map = db.ast_id_map(mod_def.file_id);
-        let item_tree = db.item_tree(mod_def.file_id);
-        let root = db.parse_or_expand(mod_def.file_id).unwrap();
-        for item in module_data.scope.declarations() {
-            match item {
-                ModuleDefId::FunctionId(it) => {
-                    // Technically blocks can be inside any type (due to arrays and const generics),
-                    // and also in const/static initializers. For tests we only really care about
-                    // functions though.
-                    let ast = ast_map.get(item_tree[it.lookup(db).id.value].ast_id).to_node(&root);
-                    if ast.syntax().text_range().contains(position.offset) {
-                        // Cursor inside function, descend into its body's DefMap.
-                        // Note that we don't handle block *expressions* inside function bodies.
-                        let ast_map = db.ast_id_map(position.file_id.into());
-                        let ast_id = ast_map.ast_id(&ast.body().unwrap());
-                        let block = BlockLoc {
-                            ast_id: InFile::new(position.file_id.into(), ast_id),
-                            module: def_map.module_id(local_id),
-                        };
-                        let block_id = db.intern_block(block);
-                        return Some(db.block_def_map(block_id));
-                    }
-                }
-                _ => continue,
-            }
-        }
-    }
-    None
 }
 fn check(ra_fixture: &str, expect: Expect) {
-    let def_map = compute_crate_def_map(ra_fixture);
+    let actual = render_crate_def_map(ra_fixture);
-    let actual = def_map.dump();
-    expect.assert_eq(&actual);
-}
-fn check_at(ra_fixture: &str, expect: Expect) {
-    let def_map = compute_block_def_map(ra_fixture);
-    let actual = def_map.dump();
    expect.assert_eq(&actual);
 }
diff --git a/crates/hir_def/src/path.rs b/crates/hir_def/src/path.rs
index 84ea09b53..0e60dc2b6 100644
--- a/crates/hir_def/src/path.rs
+++ b/crates/hir_def/src/path.rs
@@ -20,7 +20,7 @@ use crate::{
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct ModPath {
    pub kind: PathKind,
-    pub segments: Vec<Name>,
+    segments: Vec<Name>,
 }
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -53,6 +53,11 @@ impl ModPath {
        ModPath { kind, segments }
    }
+    /// Creates a `ModPath` from a `PathKind`, with no extra path segments.
+    pub const fn from_kind(kind: PathKind) -> ModPath {
+        ModPath { kind, segments: Vec::new() }
+    }
    /// Calls `cb` with all paths, represented by this use item.
    pub(crate) fn expand_use_item(
        item_src: InFile<ast::Use>,
@@ -64,6 +69,18 @@ impl ModPath {
        }
    }
+    pub fn segments(&self) -> &[Name] {
+        &self.segments
+    }
+    pub fn push_segment(&mut self, segment: Name) {
+        self.segments.push(segment);
+    }
+    pub fn pop_segment(&mut self) -> Option<Name> {
+        self.segments.pop()
+    }
    /// Returns the number of segments in the path (counting special segments like `$crate` and
    /// `super`).
    pub fn len(&self) -> usize {
@@ -78,7 +95,7 @@ impl ModPath {
    }
    pub fn is_ident(&self) -> bool {
-        self.kind == PathKind::Plain && self.segments.len() == 1
+        self.as_ident().is_some()
    }
    pub fn is_self(&self) -> bool {
@@ -87,10 +104,14 @@ impl ModPath {
    /// If this path is a single identifier, like `foo`, return its name.
    pub fn as_ident(&self) -> Option<&Name> {
-        if !self.is_ident() {
+        if self.kind != PathKind::Plain {
            return None;
        }
-        self.segments.first()
+        match &*self.segments {
+            [name] => Some(name),
+            _ => None,
+        }
    }
 }
@@ -180,10 +201,10 @@ impl Path {
        }
        let res = Path {
            type_anchor: self.type_anchor.clone(),
-            mod_path: ModPath {
+            mod_path: ModPath::from_segments(
-                kind: self.mod_path.kind.clone(),
+                self.mod_path.kind.clone(),
-                segments: self.mod_path.segments[..self.mod_path.segments.len() - 1].to_vec(),
+                self.mod_path.segments[..self.mod_path.segments.len() - 1].iter().cloned(),
-            },
+            ),
            generic_args: self.generic_args[..self.generic_args.len() - 1].to_vec(),
        };
        Some(res)
diff --git a/crates/hir_def/src/path/lower.rs b/crates/hir_def/src/path/lower.rs
index 9518ac109..a469546c1 100644
--- a/crates/hir_def/src/path/lower.rs
+++ b/crates/hir_def/src/path/lower.rs
@@ -129,7 +129,7 @@ pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path>
        }
    }
-    let mod_path = ModPath { kind, segments };
+    let mod_path = ModPath::from_segments(kind, segments);
    return Some(Path { type_anchor, mod_path, generic_args });
    fn qualifier(path: &ast::Path) -> Option<ast::Path> {
diff --git a/crates/hir_def/src/path/lower/lower_use.rs b/crates/hir_def/src/path/lower/lower_use.rs
index ba0d1f0e7..d584b0b70 100644
--- a/crates/hir_def/src/path/lower/lower_use.rs
+++ b/crates/hir_def/src/path/lower/lower_use.rs
@@ -75,9 +75,10 @@ fn convert_path(prefix: Option<ModPath>, path: ast::Path, hygiene: &Hygiene) ->
            match hygiene.name_ref_to_name(name_ref) {
                Either::Left(name) => {
                    // no type args in use
-                    let mut res = prefix.unwrap_or_else(|| ModPath {
+                    let mut res = prefix.unwrap_or_else(|| {
-                        kind: segment.coloncolon_token().map_or(PathKind::Plain, |_| PathKind::Abs),
+                        ModPath::from_kind(
-                        segments: Vec::with_capacity(1),
+                            segment.coloncolon_token().map_or(PathKind::Plain, |_| PathKind::Abs),
+                        )
                    });
                    res.segments.push(name);
                    res
diff --git a/crates/hir_def/src/resolver.rs b/crates/hir_def/src/resolver.rs
index 9021ea712..f9ad50301 100644
--- a/crates/hir_def/src/resolver.rs
+++ b/crates/hir_def/src/resolver.rs
@@ -164,7 +164,7 @@ impl Resolver {
        db: &dyn DefDatabase,
        path: &ModPath,
    ) -> Option<(TypeNs, Option<usize>)> {
-        let first_name = path.segments.first()?;
+        let first_name = path.segments().first()?;
        let skip_to_mod = path.kind != PathKind::Plain;
        for scope in self.scopes.iter().rev() {
            match scope {
@@ -179,7 +179,7 @@ impl Resolver {
                Scope::GenericParams { params, def } => {
                    if let Some(local_id) = params.find_type_by_name(first_name) {
-                        let idx = if path.segments.len() == 1 { None } else { Some(1) };
+                        let idx = if path.segments().len() == 1 { None } else { Some(1) };
                        return Some((
                            TypeNs::GenericParam(TypeParamId { local_id, parent: *def }),
                            idx,
@@ -188,13 +188,13 @@ impl Resolver {
                }
                Scope::ImplDefScope(impl_) => {
                    if first_name == &name![Self] {
-                        let idx = if path.segments.len() == 1 { None } else { Some(1) };
+                        let idx = if path.segments().len() == 1 { None } else { Some(1) };
                        return Some((TypeNs::SelfType(*impl_), idx));
                    }
                }
                Scope::AdtScope(adt) => {
                    if first_name == &name![Self] {
-                        let idx = if path.segments.len() == 1 { None } else { Some(1) };
+                        let idx = if path.segments().len() == 1 { None } else { Some(1) };
                        return Some((TypeNs::AdtSelfType(*adt), idx));
                    }
                }
@@ -270,9 +270,9 @@ impl Resolver {
        db: &dyn DefDatabase,
        path: &ModPath,
    ) -> Option<ResolveValueResult> {
-        let n_segments = path.segments.len();
+        let n_segments = path.segments().len();
        let tmp = name![self];
-        let first_name = if path.is_self() { &tmp } else { path.segments.first()? };
+        let first_name = if path.is_self() { &tmp } else { path.segments().first()? };
        let skip_to_mod = path.kind != PathKind::Plain && !path.is_self();
        for scope in self.scopes.iter().rev() {
            match scope {
diff --git a/crates/hir_def/src/visibility.rs b/crates/hir_def/src/visibility.rs
index e79a91102..38da3132b 100644
--- a/crates/hir_def/src/visibility.rs
+++ b/crates/hir_def/src/visibility.rs
@@ -22,8 +22,7 @@ pub enum RawVisibility {
 impl RawVisibility {
    pub(crate) const fn private() -> RawVisibility {
-        let path = ModPath { kind: PathKind::Super(0), segments: Vec::new() };
+        RawVisibility::Module(ModPath::from_kind(PathKind::Super(0)))
-        RawVisibility::Module(path)
    }
    pub(crate) fn from_ast(
@@ -59,15 +58,15 @@ impl RawVisibility {
                RawVisibility::Module(path)
            }
            ast::VisibilityKind::PubCrate => {
-                let path = ModPath { kind: PathKind::Crate, segments: Vec::new() };
+                let path = ModPath::from_kind(PathKind::Crate);
                RawVisibility::Module(path)
            }
            ast::VisibilityKind::PubSuper => {
-                let path = ModPath { kind: PathKind::Super(1), segments: Vec::new() };
+                let path = ModPath::from_kind(PathKind::Super(1));
                RawVisibility::Module(path)
            }
            ast::VisibilityKind::PubSelf => {
-                let path = ModPath { kind: PathKind::Plain, segments: Vec::new() };
+                let path = ModPath::from_kind(PathKind::Plain);
                RawVisibility::Module(path)
            }
            ast::VisibilityKind::Pub => RawVisibility::Public,
diff --git a/crates/hir_ty/src/diagnostics.rs b/crates/hir_ty/src/diagnostics.rs
index 323c5f963..08483760c 100644
--- a/crates/hir_ty/src/diagnostics.rs
+++ b/crates/hir_ty/src/diagnostics.rs
@@ -345,6 +345,37 @@ impl fmt::Display for CaseType {
    }
 }
+#[derive(Debug)]
+pub enum IdentType {
+    Argument,
+    Constant,
+    Enum,
+    Field,
+    Function,
+    StaticVariable,
+    Structure,
+    Variable,
+    Variant,
+}
+impl fmt::Display for IdentType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let repr = match self {
+            IdentType::Argument => "Argument",
+            IdentType::Constant => "Constant",
+            IdentType::Enum => "Enum",
+            IdentType::Field => "Field",
+            IdentType::Function => "Function",
+            IdentType::StaticVariable => "Static variable",
+            IdentType::Structure => "Structure",
+            IdentType::Variable => "Variable",
+            IdentType::Variant => "Variant",
+        };
+        write!(f, "{}", repr)
+    }
+}
 // Diagnostic: incorrect-ident-case
 //
 // This diagnostic is triggered if an item name doesn't follow https://doc.rust-lang.org/1.0.0/style/style/naming/README.html[Rust naming convention].
@@ -353,7 +384,7 @@ pub struct IncorrectCase {
    pub file: HirFileId,
    pub ident: AstPtr<ast::Name>,
    pub expected_case: CaseType,
-    pub ident_type: String,
+    pub ident_type: IdentType,
    pub ident_text: String,
    pub suggested_text: String,
 }
diff --git a/crates/hir_ty/src/diagnostics/decl_check.rs b/crates/hir_ty/src/diagnostics/decl_check.rs
index eaeb6899f..6773ddea3 100644
--- a/crates/hir_ty/src/diagnostics/decl_check.rs
+++ b/crates/hir_ty/src/diagnostics/decl_check.rs
@@ -23,6 +23,7 @@ use hir_expand::{
    diagnostics::DiagnosticSink,
    name::{AsName, Name},
 };
+use stdx::{always, never};
 use syntax::{
    ast::{self, NameOwner},
    AstNode, AstPtr,
@@ -31,7 +32,7 @@ use test_utils::mark;
 use crate::{
    db::HirDatabase,
-    diagnostics::{decl_check::case_conv::*, CaseType, IncorrectCase},
+    diagnostics::{decl_check::case_conv::*, CaseType, IdentType, IncorrectCase},
 };
 mod allow {
@@ -40,7 +41,7 @@ mod allow {
    pub(super) const NON_CAMEL_CASE_TYPES: &str = "non_camel_case_types";
 }
-pub(super) struct DeclValidator<'a, 'b: 'a> {
+pub(super) struct DeclValidator<'a, 'b> {
    db: &'a dyn HirDatabase,
    krate: CrateId,
    sink: &'a mut DiagnosticSink<'b>,
@@ -77,7 +78,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
            AdtId::StructId(struct_id) => self.validate_struct(struct_id),
            AdtId::EnumId(enum_id) => self.validate_enum(enum_id),
            AdtId::UnionId(_) => {
-                // Unions aren't yet supported by this validator.
+                // FIXME: Unions aren't yet supported by this validator.
            }
        }
    }
@@ -111,63 +112,50 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
        // Check the function name.
        let function_name = data.name.to_string();
-        let fn_name_replacement = if let Some(new_name) = to_lower_snake_case(&function_name) {
+        let fn_name_replacement = to_lower_snake_case(&function_name).map(|new_name| Replacement {
-            let replacement = Replacement {
+            current_name: data.name.clone(),
-                current_name: data.name.clone(),
+            suggested_text: new_name,
-                suggested_text: new_name,
+            expected_case: CaseType::LowerSnakeCase,
-                expected_case: CaseType::LowerSnakeCase,
+        });
-            };
-            Some(replacement)
-        } else {
-            None
-        };
        // Check the param names.
-        let mut fn_param_replacements = Vec::new();
+        let fn_param_replacements = body
+            .params
-        for pat_id in body.params.iter().cloned() {
+            .iter()
-            let pat = &body[pat_id];
+            .filter_map(|&id| match &body[id] {
+                Pat::Bind { name, .. } => Some(name),
-            let param_name = match pat {
+                _ => None,
-                Pat::Bind { name, .. } => name,
+            })
-                _ => continue,
+            .filter_map(|param_name| {
-            };
+                Some(Replacement {
-            let name = param_name.to_string();
-            if let Some(new_name) = to_lower_snake_case(&name) {
-                let replacement = Replacement {
                    current_name: param_name.clone(),
-                    suggested_text: new_name,
+                    suggested_text: to_lower_snake_case(&param_name.to_string())?,
                    expected_case: CaseType::LowerSnakeCase,
-                };
+                })
-                fn_param_replacements.push(replacement);
+            })
-            }
+            .collect();
-        }
        // Check the patterns inside the function body.
-        let mut pats_replacements = Vec::new();
+        let pats_replacements = body
+            .pats
-        for (pat_idx, pat) in body.pats.iter() {
+            .iter()
-            if body.params.contains(&pat_idx) {
+            // We aren't interested in function parameters, we've processed them above.
-                // We aren't interested in function parameters, we've processed them above.
+            .filter(|(pat_idx, _)| !body.params.contains(&pat_idx))
-                continue;
+            .filter_map(|(id, pat)| match pat {
-            }
+                Pat::Bind { name, .. } => Some((id, name)),
+                _ => None,
-            let bind_name = match pat {
+            })
-                Pat::Bind { name, .. } => name,
+            .filter_map(|(id, bind_name)| {
-                _ => continue,
+                Some((
-            };
+                    id,
+                    Replacement {
-            let name = bind_name.to_string();
+                        current_name: bind_name.clone(),
-            if let Some(new_name) = to_lower_snake_case(&name) {
+                        suggested_text: to_lower_snake_case(&bind_name.to_string())?,
-                let replacement = Replacement {
+                        expected_case: CaseType::LowerSnakeCase,
-                    current_name: bind_name.clone(),
+                    },
-                    suggested_text: new_name,
+                ))
-                    expected_case: CaseType::LowerSnakeCase,
+            })
-                };
+            .collect();
-                pats_replacements.push((pat_idx, replacement));
-            }
-        }
        // If there is at least one element to spawn a warning on, go to the source map and generate a warning.
        self.create_incorrect_case_diagnostic_for_func(
@@ -199,8 +187,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
            let ast_ptr = match fn_src.value.name() {
                Some(name) => name,
                None => {
-                    // We don't want rust-analyzer to panic over this, but it is definitely some kind of error in the logic.
+                    never!(
-                    log::error!(
                        "Replacement ({:?}) was generated for a function without a name: {:?}",
                        replacement,
                        fn_src
@@ -211,7 +198,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
            let diagnostic = IncorrectCase {
                file: fn_src.file_id,
-                ident_type: "Function".to_string(),
+                ident_type: IdentType::Function,
                ident: AstPtr::new(&ast_ptr).into(),
                expected_case: replacement.expected_case,
                ident_text: replacement.current_name.to_string(),
@@ -225,12 +212,12 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
        let fn_params_list = match fn_src.value.param_list() {
            Some(params) => params,
            None => {
-                if !fn_param_replacements.is_empty() {
+                always!(
-                    log::error!(
+                    fn_param_replacements.is_empty(),
-                        "Replacements ({:?}) were generated for a function parameters which had no parameters list: {:?}",
+                    "Replacements ({:?}) were generated for a function parameters which had no parameters list: {:?}",
-                        fn_param_replacements, fn_src
+                    fn_param_replacements,
-                    );
+                    fn_src
-                }
+                );
                return;
            }
        };
@@ -240,23 +227,25 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
            // actual params list, but just some of them (ones that named correctly) are skipped.
            let ast_ptr: ast::Name = loop {
                match fn_params_iter.next() {
-                    Some(element)
+                    Some(element) => {
-                        if pat_equals_to_name(element.pat(), &param_to_rename.current_name) =>
+                        if let Some(ast::Pat::IdentPat(pat)) = element.pat() {
-                    {
+                            if pat.to_string() == param_to_rename.current_name.to_string() {
-                        if let ast::Pat::IdentPat(pat) = element.pat().unwrap() {
+                                if let Some(name) = pat.name() {
-                            break pat.name().unwrap();
+                                    break name;
-                        } else {
+                                }
-                            // This is critical. If we consider this parameter the expected one,
+                                // This is critical. If we consider this parameter the expected one,
-                            // it **must** have a name.
+                                // it **must** have a name.
-                            panic!(
+                                never!(
-                                "Pattern {:?} equals to expected replacement {:?}, but has no name",
+                                    "Pattern {:?} equals to expected replacement {:?}, but has no name",
-                                element, param_to_rename
+                                    element,
-                            );
+                                    param_to_rename
+                                );
+                                return;
+                            }
                        }
                    }
-                    Some(_) => {}
                    None => {
-                        log::error!(
+                        never!(
                            "Replacement ({:?}) was generated for a function parameter which was not found: {:?}",
                            param_to_rename, fn_src
                        );
@@ -267,7 +256,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
            let diagnostic = IncorrectCase {
                file: fn_src.file_id,
-                ident_type: "Argument".to_string(),
+                ident_type: IdentType::Argument,
                ident: AstPtr::new(&ast_ptr).into(),
                expected_case: param_to_rename.expected_case,
                ident_text: param_to_rename.current_name.to_string(),
@@ -309,8 +298,8 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
                        // We have to check that it's either `let var = ...` or `var @ Variant(_)` statement,
                        // because e.g. match arms are patterns as well.
                        // In other words, we check that it's a named variable binding.
-                        let is_binding = ast::LetStmt::cast(parent.clone()).is_some()
+                        let is_binding = ast::LetStmt::can_cast(parent.kind())
-                            || (ast::MatchArm::cast(parent).is_some()
+                            || (ast::MatchArm::can_cast(parent.kind())
                                && ident_pat.at_token().is_some());
                        if !is_binding {
                            // This pattern is not an actual variable declaration, e.g. `Some(val) => {..}` match arm.
@@ -319,7 +308,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
                        let diagnostic = IncorrectCase {
                            file: source_ptr.file_id,
-                            ident_type: "Variable".to_string(),
+                            ident_type: IdentType::Variable,
                            ident: AstPtr::new(&name_ast).into(),
                            expected_case: replacement.expected_case,
                            ident_text: replacement.current_name.to_string(),
@@ -341,17 +330,12 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
        // Check the structure name.
        let struct_name = data.name.to_string();
-        let struct_name_replacement = if let Some(new_name) = to_camel_case(&struct_name) {
+        let struct_name_replacement = if !non_camel_case_allowed {
-            let replacement = Replacement {
+            to_camel_case(&struct_name).map(|new_name| Replacement {
                current_name: data.name.clone(),
                suggested_text: new_name,
                expected_case: CaseType::UpperCamelCase,
-            };
+            })
-            if non_camel_case_allowed {
-                None
-            } else {
-                Some(replacement)
-            }
        } else {
            None
        };
@@ -403,8 +387,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
            let ast_ptr = match struct_src.value.name() {
                Some(name) => name,
                None => {
-                    // We don't want rust-analyzer to panic over this, but it is definitely some kind of error in the logic.
+                    never!(
-                    log::error!(
                        "Replacement ({:?}) was generated for a structure without a name: {:?}",
                        replacement,
                        struct_src
@@ -415,7 +398,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
            let diagnostic = IncorrectCase {
                file: struct_src.file_id,
-                ident_type: "Structure".to_string(),
+                ident_type: IdentType::Structure,
                ident: AstPtr::new(&ast_ptr).into(),
                expected_case: replacement.expected_case,
                ident_text: replacement.current_name.to_string(),
@@ -428,12 +411,12 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
        let struct_fields_list = match struct_src.value.field_list() {
            Some(ast::FieldList::RecordFieldList(fields)) => fields,
            _ => {
-                if !struct_fields_replacements.is_empty() {
+                always!(
-                    log::error!(
+                    struct_fields_replacements.is_empty(),
-                        "Replacements ({:?}) were generated for a structure fields which had no fields list: {:?}",
+                    "Replacements ({:?}) were generated for a structure fields which had no fields list: {:?}",
-                        struct_fields_replacements, struct_src
+                    struct_fields_replacements,
-                    );
+                    struct_src
-                }
+                );
                return;
            }
        };
@@ -442,13 +425,14 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
            // We assume that parameters in replacement are in the same order as in the
            // actual params list, but just some of them (ones that named correctly) are skipped.
            let ast_ptr = loop {
-                match struct_fields_iter.next() {
+                match struct_fields_iter.next().and_then(|field| field.name()) {
-                    Some(element) if names_equal(element.name(), &field_to_rename.current_name) => {
+                    Some(field_name) => {
-                        break element.name().unwrap()
+                        if field_name.as_name() == field_to_rename.current_name {
+                            break field_name;
+                        }
                    }
-                    Some(_) => {}
                    None => {
-                        log::error!(
+                        never!(
                            "Replacement ({:?}) was generated for a structure field which was not found: {:?}",
                            field_to_rename, struct_src
                        );
@@ -459,7 +443,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
            let diagnostic = IncorrectCase {
                file: struct_src.file_id,
-                ident_type: "Field".to_string(),
+                ident_type: IdentType::Field,
                ident: AstPtr::new(&ast_ptr).into(),
                expected_case: field_to_rename.expected_case,
                ident_text: field_to_rename.current_name.to_string(),
@@ -480,31 +464,24 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
        // Check the enum name.
        let enum_name = data.name.to_string();
-        let enum_name_replacement = if let Some(new_name) = to_camel_case(&enum_name) {
+        let enum_name_replacement = to_camel_case(&enum_name).map(|new_name| Replacement {
-            let replacement = Replacement {
+            current_name: data.name.clone(),
-                current_name: data.name.clone(),
+            suggested_text: new_name,
-                suggested_text: new_name,
+            expected_case: CaseType::UpperCamelCase,
-                expected_case: CaseType::UpperCamelCase,
+        });
-            };
-            Some(replacement)
-        } else {
-            None
-        };
        // Check the field names.
-        let mut enum_fields_replacements = Vec::new();
+        let enum_fields_replacements = data
+            .variants
-        for (_, variant) in data.variants.iter() {
+            .iter()
-            let variant_name = variant.name.to_string();
+            .filter_map(|(_, variant)| {
-            if let Some(new_name) = to_camel_case(&variant_name) {
+                Some(Replacement {
-                let replacement = Replacement {
                    current_name: variant.name.clone(),
-                    suggested_text: new_name,
+                    suggested_text: to_camel_case(&variant.name.to_string())?,
                    expected_case: CaseType::UpperCamelCase,
-                };
+                })
-                enum_fields_replacements.push(replacement);
+            })
-            }
+            .collect();
-        }
        // If there is at least one element to spawn a warning on, go to the source map and generate a warning.
        self.create_incorrect_case_diagnostic_for_enum(
@@ -534,8 +511,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
            let ast_ptr = match enum_src.value.name() {
                Some(name) => name,
                None => {
-                    // We don't want rust-analyzer to panic over this, but it is definitely some kind of error in the logic.
+                    never!(
-                    log::error!(
                        "Replacement ({:?}) was generated for a enum without a name: {:?}",
                        replacement,
                        enum_src
@@ -546,7 +522,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
            let diagnostic = IncorrectCase {
                file: enum_src.file_id,
-                ident_type: "Enum".to_string(),
+                ident_type: IdentType::Enum,
                ident: AstPtr::new(&ast_ptr).into(),
                expected_case: replacement.expected_case,
                ident_text: replacement.current_name.to_string(),
@@ -559,12 +535,12 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
        let enum_variants_list = match enum_src.value.variant_list() {
            Some(variants) => variants,
            _ => {
-                if !enum_variants_replacements.is_empty() {
+                always!(
-                    log::error!(
+                    enum_variants_replacements.is_empty(),
-                        "Replacements ({:?}) were generated for a enum variants which had no fields list: {:?}",
+                    "Replacements ({:?}) were generated for a enum variants which had no fields list: {:?}",
-                        enum_variants_replacements, enum_src
+                    enum_variants_replacements,
-                    );
+                    enum_src
-                }
+                );
                return;
            }
        };
@@ -573,15 +549,14 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
            // We assume that parameters in replacement are in the same order as in the
            // actual params list, but just some of them (ones that named correctly) are skipped.
            let ast_ptr = loop {
-                match enum_variants_iter.next() {
+                match enum_variants_iter.next().and_then(|v| v.name()) {
-                    Some(variant)
+                    Some(variant_name) => {
-                        if names_equal(variant.name(), &variant_to_rename.current_name) =>
+                        if variant_name.as_name() == variant_to_rename.current_name {
-                    {
+                            break variant_name;
-                        break variant.name().unwrap()
+                        }
                    }
-                    Some(_) => {}
                    None => {
-                        log::error!(
+                        never!(
                            "Replacement ({:?}) was generated for a enum variant which was not found: {:?}",
                            variant_to_rename, enum_src
                        );
@@ -592,7 +567,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
            let diagnostic = IncorrectCase {
                file: enum_src.file_id,
-                ident_type: "Variant".to_string(),
+                ident_type: IdentType::Variant,
                ident: AstPtr::new(&ast_ptr).into(),
                expected_case: variant_to_rename.expected_case,
                ident_text: variant_to_rename.current_name.to_string(),
@@ -637,7 +612,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
        let diagnostic = IncorrectCase {
            file: const_src.file_id,
-            ident_type: "Constant".to_string(),
+            ident_type: IdentType::Constant,
            ident: AstPtr::new(&ast_ptr).into(),
            expected_case: replacement.expected_case,
            ident_text: replacement.current_name.to_string(),
@@ -685,7 +660,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
        let diagnostic = IncorrectCase {
            file: static_src.file_id,
-            ident_type: "Static variable".to_string(),
+            ident_type: IdentType::StaticVariable,
            ident: AstPtr::new(&ast_ptr).into(),
            expected_case: replacement.expected_case,
            ident_text: replacement.current_name.to_string(),
@@ -696,22 +671,6 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
    }
 }
-fn names_equal(left: Option<ast::Name>, right: &Name) -> bool {
-    if let Some(left) = left {
-        &left.as_name() == right
-    } else {
-        false
-    }
-}
-fn pat_equals_to_name(pat: Option<ast::Pat>, name: &Name) -> bool {
-    if let Some(ast::Pat::IdentPat(ident)) = pat {
-        ident.to_string() == name.to_string()
-    } else {
-        false
-    }
-}
 #[cfg(test)]
 mod tests {
    use test_utils::mark;
diff --git a/crates/hir_ty/src/diagnostics/decl_check/case_conv.rs b/crates/hir_ty/src/diagnostics/decl_check/case_conv.rs
index 14e4d92f0..3ab36caf2 100644
--- a/crates/hir_ty/src/diagnostics/decl_check/case_conv.rs
+++ b/crates/hir_ty/src/diagnostics/decl_check/case_conv.rs
@@ -5,7 +5,7 @@
 // from file /compiler/rustc_lint/src/nonstandard_style.rs
 /// Converts an identifier to an UpperCamelCase form.
-/// Returns `None` if the string is already is UpperCamelCase.
+/// Returns `None` if the string is already in UpperCamelCase.
 pub(crate) fn to_camel_case(ident: &str) -> Option<String> {
    if is_camel_case(ident) {
        return None;
@@ -17,7 +17,7 @@ pub(crate) fn to_camel_case(ident: &str) -> Option<String> {
        .split('_')
        .filter(|component| !component.is_empty())
        .map(|component| {
-            let mut camel_cased_component = String::new();
+            let mut camel_cased_component = String::with_capacity(component.len());
            let mut new_word = true;
            let mut prev_is_lower_case = true;
@@ -30,9 +30,9 @@ pub(crate) fn to_camel_case(ident: &str) -> Option<String> {
                }
                if new_word {
-                    camel_cased_component.push_str(&c.to_uppercase().to_string());
+                    camel_cased_component.extend(c.to_uppercase());
                } else {
-                    camel_cased_component.push_str(&c.to_lowercase().to_string());
+                    camel_cased_component.extend(c.to_lowercase());
                }
                prev_is_lower_case = c.is_lowercase();
@@ -41,16 +41,16 @@ pub(crate) fn to_camel_case(ident: &str) -> Option<String> {
            camel_cased_component
        })
-        .fold((String::new(), None), |(acc, prev): (String, Option<String>), next| {
+        .fold((String::new(), None), |(acc, prev): (_, Option<String>), next| {
            // separate two components with an underscore if their boundary cannot
            // be distinguished using a uppercase/lowercase case distinction
-            let join = if let Some(prev) = prev {
+            let join = prev
-                let l = prev.chars().last().unwrap();
+                .and_then(|prev| {
-                let f = next.chars().next().unwrap();
+                    let f = next.chars().next()?;
-                !char_has_case(l) && !char_has_case(f)
+                    let l = prev.chars().last()?;
-            } else {
+                    Some(!char_has_case(l) && !char_has_case(f))
-                false
+                })
-            };
+                .unwrap_or(false);
            (acc + if join { "_" } else { "" } + &next, Some(next))
        })
        .0;
@@ -92,14 +92,12 @@ fn is_camel_case(name: &str) -> bool {
    let mut fst = None;
    // start with a non-lowercase letter rather than non-uppercase
    // ones (some scripts don't have a concept of upper/lowercase)
-    !name.chars().next().unwrap().is_lowercase()
+    name.chars().next().map_or(true, |c| !c.is_lowercase())
        && !name.contains("__")
        && !name.chars().any(|snd| {
-            let ret = match (fst, snd) {
+            let ret = match fst {
-                (None, _) => false,
+                None => false,
-                (Some(fst), snd) => {
+                Some(fst) => char_has_case(fst) && snd == '_' || char_has_case(snd) && fst == '_',
-                    char_has_case(fst) && snd == '_' || char_has_case(snd) && fst == '_'
-                }
            };
            fst = Some(snd);
diff --git a/crates/hir_ty/src/infer.rs b/crates/hir_ty/src/infer.rs
index d08867c70..4b683c5a7 100644
--- a/crates/hir_ty/src/infer.rs
+++ b/crates/hir_ty/src/infer.rs
@@ -461,7 +461,7 @@ impl<'a> InferenceContext<'a> {
                        (ty, variant)
                    }
                    Some(1) => {
-                        let segment = path.mod_path().segments.last().unwrap();
+                        let segment = path.mod_path().segments().last().unwrap();
                        // this could be an enum variant or associated type
                        if let Some((AdtId::EnumId(enum_id), _)) = ty.as_adt() {
                            let enum_data = self.db.enum_data(enum_id);
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index d7351d212..12f1591c8 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -137,7 +137,7 @@ impl<'a> InferenceContext<'a> {
                self.coerce_merge_branch(&then_ty, &else_ty)
            }
-            Expr::Block { statements, tail, label } => match label {
+            Expr::Block { statements, tail, label, id: _ } => match label {
                Some(_) => {
                    let break_ty = self.table.new_type_var();
                    self.breakables.push(BreakableContext {
diff --git a/crates/ide_db/src/helpers.rs b/crates/ide_db/src/helpers.rs
index 0dcc4dd29..bc7aee110 100644
--- a/crates/ide_db/src/helpers.rs
+++ b/crates/ide_db/src/helpers.rs
@@ -24,7 +24,7 @@ pub fn mod_path_to_ast(path: &hir::ModPath) -> ast::Path {
    }
    segments.extend(
-        path.segments
+        path.segments()
            .iter()
            .map(|segment| make::path_segment(make::name_ref(&segment.to_string()))),
    );
diff --git a/crates/mbe/Cargo.toml b/crates/mbe/Cargo.toml
index 43bc10490..ef0907194 100644
--- a/crates/mbe/Cargo.toml
+++ b/crates/mbe/Cargo.toml
@@ -17,5 +17,5 @@ log = "0.4.8"
 syntax = { path = "../syntax", version = "0.0.0" }
 parser = { path = "../parser", version = "0.0.0" }
 tt = { path = "../tt", version = "0.0.0" }
-test_utils = { path = "../test_utils" }
+test_utils = { path = "../test_utils", version = "0.0.0" }
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 07204436c..5a6501216 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -1729,7 +1729,7 @@ fn fill_resolve_data(
 ) -> Option<()> {
    let import_edit = item.import_to_add()?;
    let full_import_path = import_edit.import_path.to_string();
-    let imported_name = import_edit.import_path.segments.clone().pop()?.to_string();
+    let imported_name = import_edit.import_path.segments().last()?.to_string();
    *resolve_data = Some(
        to_value(CompletionResolveData {
diff --git a/crates/stdx/Cargo.toml b/crates/stdx/Cargo.toml
index 5866c0a28..d28b5e658 100644
--- a/crates/stdx/Cargo.toml
+++ b/crates/stdx/Cargo.toml
@@ -11,7 +11,7 @@ doctest = false
 [dependencies]
 backtrace = { version = "0.3.44", optional = true }
-always-assert = { version = "0.1.1", features = ["log"] }
+always-assert = { version = "0.1.2", features = ["log"] }
 # Think twice before adding anything here
 [features]
diff --git a/crates/syntax/fuzz/Cargo.toml b/crates/syntax/fuzz/Cargo.toml
index 32c40d1b9..e22cd6b0c 100644
--- a/crates/syntax/fuzz/Cargo.toml
+++ b/crates/syntax/fuzz/Cargo.toml
@@ -10,8 +10,8 @@ edition = "2018"
 cargo-fuzz = true
 [dependencies]
-syntax = { path = ".." }
+syntax = { path = "..", version = "0.0.0" }
-text_edit = { path = "../../text_edit" }
+text_edit = { path = "../../text_edit", version = "0.0.0" }
 libfuzzer-sys = { git = "https://github.com/rust-fuzz/libfuzzer-sys.git" }
 # Prevent this from interfering with workspaces
diff --git a/crates/syntax/src/ast/make.rs b/crates/syntax/src/ast/make.rs
index b755c9692..1da5a125e 100644
--- a/crates/syntax/src/ast/make.rs
+++ b/crates/syntax/src/ast/make.rs
@@ -487,7 +487,7 @@ pub mod tokens {
    use crate::{ast, AstNode, Parse, SourceFile, SyntaxKind::*, SyntaxToken};
    pub(super) static SOURCE_FILE: Lazy<Parse<SourceFile>> =
-        Lazy::new(|| SourceFile::parse("const C: <()>::Item = (1 != 1, 2 == 2, !true)\n;\n\n"));
+        Lazy::new(|| SourceFile::parse("const C: <()>::Item = (1 != 1, 2 == 2, !true, *p)\n;\n\n"));
    pub fn single_space() -> SyntaxToken {
        SOURCE_FILE