rust-analyzer subtree update

src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs

@@ -328,11 +328,7 @@ impl<'db> CastCheck<'db> {
                     //
                     // Note that trait upcasting goes through a different mechanism (`coerce_unsized`)
                     // and is unaffected by this check.
-                    (Some(src_principal), Some(dst_principal)) => {
-                        if src_principal == dst_principal {
-                            return Ok(());
-                        }
-
+                    (Some(src_principal), Some(_)) => {
                         // We need to reconstruct trait object types.
                         // `m_src` and `m_dst` won't work for us here because they will potentially
                         // contain wrappers, which we do not care about.

src/tools/rust-analyzer/crates/ide-assists/src/handlers/fix_visibility.rs

@@ -2,7 +2,7 @@ use hir::{HasSource, HasVisibility, ModuleDef, PathResolution, ScopeDef, db::Hir
 use ide_db::FileId;
 use syntax::{
     AstNode, TextRange,
-    ast::{self, HasVisibility as _, edit_in_place::HasVisibilityEdit, make},
+    ast::{self, HasVisibility as _, syntax_factory::SyntaxFactory},
 };
 
 use crate::{AssistContext, AssistId, Assists};
@@ -59,10 +59,12 @@ fn add_vis_to_referenced_module_def(acc: &mut Assists, ctx: &AssistContext<'_>)
 
     let (vis_owner, target, target_file, target_name) = target_data_for_def(ctx.db(), def)?;
 
+    let make = SyntaxFactory::without_mappings();
+
     let missing_visibility = if current_module.krate(ctx.db()) == target_module.krate(ctx.db()) {
-        make::visibility_pub_crate()
+        make.visibility_pub_crate()
     } else {
-        make::visibility_pub()
+        make.visibility_pub()
     };
 
     let assist_label = match target_name {
@@ -75,15 +77,36 @@ fn add_vis_to_referenced_module_def(acc: &mut Assists, ctx: &AssistContext<'_>)
         }
     };
 
-    acc.add(AssistId::quick_fix("fix_visibility"), assist_label, target, |edit| {
-        edit.edit_file(target_file);
-
-        let vis_owner = edit.make_mut(vis_owner);
-        vis_owner.set_visibility(Some(missing_visibility.clone_for_update()));
+    acc.add(AssistId::quick_fix("fix_visibility"), assist_label, target, |builder| {
+        let mut editor = builder.make_editor(vis_owner.syntax());
+
+        if let Some(current_visibility) = vis_owner.visibility() {
+            editor.replace(current_visibility.syntax(), missing_visibility.syntax());
+        } else {
+            let vis_before = vis_owner
+                .syntax()
+                .children_with_tokens()
+                .find(|it| {
+                    !matches!(
+                        it.kind(),
+                        syntax::SyntaxKind::WHITESPACE
+                            | syntax::SyntaxKind::COMMENT
+                            | syntax::SyntaxKind::ATTR
+                    )
+                })
+                .unwrap_or_else(|| vis_owner.syntax().first_child_or_token().unwrap());
+
+            editor.insert_all(
+                syntax::syntax_editor::Position::before(vis_before),
+                vec![missing_visibility.syntax().clone().into(), make.whitespace(" ").into()],
+            );
+        }
 
-        if let Some((cap, vis)) = ctx.config.snippet_cap.zip(vis_owner.visibility()) {
-            edit.add_tabstop_before(cap, vis);
+        if let Some(cap) = ctx.config.snippet_cap {
+            editor.add_annotation(missing_visibility.syntax(), builder.make_tabstop_before(cap));
         }
+
+        builder.add_file_edits(target_file, editor);
     })
 }
 

src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_derive.rs

@@ -1,7 +1,7 @@
 use syntax::{
     SyntaxKind::{ATTR, COMMENT, WHITESPACE},
     T,
-    ast::{self, AstNode, HasAttrs, edit::IndentLevel, make},
+    ast::{self, AstNode, HasAttrs, edit::IndentLevel, syntax_factory::SyntaxFactory},
     syntax_editor::{Element, Position},
 };
 
@@ -42,13 +42,15 @@ pub(crate) fn generate_derive(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opt
     };
 
     acc.add(AssistId::generate("generate_derive"), "Add `#[derive]`", target, |edit| {
+        let make = SyntaxFactory::without_mappings();
+
         match derive_attr {
             None => {
-                let derive = make::attr_outer(make::meta_token_tree(
-                    make::ext::ident_path("derive"),
-                    make::token_tree(T!['('], vec![]).clone_for_update(),
-                ))
-                .clone_for_update();
+                let derive =
+                    make.attr_outer(make.meta_token_tree(
+                        make.ident_path("derive"),
+                        make.token_tree(T!['('], vec![]),
+                    ));
 
                 let mut editor = edit.make_editor(nominal.syntax());
                 let indent = IndentLevel::from_node(nominal.syntax());
@@ -57,11 +59,12 @@ pub(crate) fn generate_derive(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opt
                     .children_with_tokens()
                     .find(|it| !matches!(it.kind(), WHITESPACE | COMMENT | ATTR))
                     .map_or(Position::first_child_of(nominal.syntax()), Position::before);
+
                 editor.insert_all(
                     after_attrs_and_comments,
                     vec![
                         derive.syntax().syntax_element(),
-                        make::tokens::whitespace(&format!("\n{indent}")).syntax_element(),
+                        make.whitespace(&format!("\n{indent}")).syntax_element(),
                     ],
                 );
 
@@ -72,7 +75,9 @@ pub(crate) fn generate_derive(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opt
                     .expect("failed to get token tree out of Meta")
                     .r_paren_token()
                     .expect("make::attr_outer was expected to have a R_PAREN");
+
                 let tabstop_before = edit.make_tabstop_before(cap);
+
                 editor.add_annotation(delimiter, tabstop_before);
                 edit.add_file_edits(ctx.vfs_file_id(), editor);
             }

src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_if_let_with_match.rs

@@ -57,7 +57,7 @@ pub(crate) fn replace_if_let_with_match(acc: &mut Assists, ctx: &AssistContext<'
     let if_exprs = successors(Some(if_expr.clone()), |expr| match expr.else_branch()? {
         ast::ElseBranch::IfExpr(expr) => Some(expr),
         ast::ElseBranch::Block(block) => {
-            let block = unwrap_trivial_block(block).clone_for_update();
+            let block = unwrap_trivial_block(block);
             else_block = Some(block.reset_indent().indent(IndentLevel(1)));
             None
         }
@@ -91,7 +91,7 @@ pub(crate) fn replace_if_let_with_match(acc: &mut Assists, ctx: &AssistContext<'
             guard
         };
 
-        let body = if_expr.then_branch()?.clone_for_update().indent(IndentLevel(1));
+        let body = if_expr.then_branch()?.indent(IndentLevel(1));
         cond_bodies.push((cond, guard, body));
     }
 
@@ -114,7 +114,7 @@ pub(crate) fn replace_if_let_with_match(acc: &mut Assists, ctx: &AssistContext<'
                 let make_match_arm =
                     |(pat, guard, body): (_, Option<ast::Expr>, ast::BlockExpr)| {
                         // Dedent from original position, then indent for match arm
-                        let body = body.dedent(indent).indent(IndentLevel::single());
+                        let body = body.dedent(indent);
                         let body = unwrap_trivial_block(body);
                         match (pat, guard.map(|it| make.match_guard(it))) {
                             (Some(pat), guard) => make.match_arm(pat, guard, body),
@@ -127,8 +127,8 @@ pub(crate) fn replace_if_let_with_match(acc: &mut Assists, ctx: &AssistContext<'
                         }
                     };
                 let arms = cond_bodies.into_iter().map(make_match_arm).chain([else_arm]);
-                let match_expr =
-                    make.expr_match(scrutinee_to_be_expr, make.match_arm_list(arms)).indent(indent);
+                let expr = scrutinee_to_be_expr.reset_indent();
+                let match_expr = make.expr_match(expr, make.match_arm_list(arms)).indent(indent);
                 match_expr.into()
             };
 
@@ -246,7 +246,7 @@ pub(crate) fn replace_match_with_if_let(acc: &mut Assists, ctx: &AssistContext<'
         first_arm.guard(),
         second_arm.guard(),
     )?;
-    let scrutinee = match_expr.expr()?;
+    let scrutinee = match_expr.expr()?.reset_indent();
     let guard = guard.and_then(|it| it.condition());
 
     let let_ = match &if_let_pat {
@@ -293,10 +293,8 @@ pub(crate) fn replace_match_with_if_let(acc: &mut Assists, ctx: &AssistContext<'
             } else {
                 condition
             };
-            let then_expr =
-                then_expr.clone_for_update().reset_indent().indent(IndentLevel::single());
-            let else_expr =
-                else_expr.clone_for_update().reset_indent().indent(IndentLevel::single());
+            let then_expr = then_expr.reset_indent();
+            let else_expr = else_expr.reset_indent();
             let then_block = make_block_expr(then_expr);
             let else_expr = if is_empty_expr(&else_expr) { None } else { Some(else_expr) };
             let if_let_expr = make
@@ -956,7 +954,9 @@ fn foo(x: Result<i32, ()>) {
             r#"
 fn main() {
     if true {
-        $0if let Ok(rel_path) = path.strip_prefix(root_path) {
+        $0if let Ok(rel_path) = path.strip_prefix(root_path)
+            .and(x)
+        {
             let rel_path = RelativePathBuf::from_path(rel_path)
                 .ok()?;
             Some((*id, rel_path))
@@ -971,7 +971,8 @@ fn main() {
             r#"
 fn main() {
     if true {
-        match path.strip_prefix(root_path) {
+        match path.strip_prefix(root_path)
+            .and(x) {
             Ok(rel_path) => {
                 let rel_path = RelativePathBuf::from_path(rel_path)
                     .ok()?;
@@ -993,7 +994,9 @@ fn main() {
             r#"
 fn main() {
     if true {
-        $0if let Ok(rel_path) = path.strip_prefix(root_path) {
+        $0if let Ok(rel_path) = path.strip_prefix(root_path)
+            .and(x)
+        {
             Foo {
                 x: 1
             }
@@ -1008,7 +1011,8 @@ fn main() {
             r#"
 fn main() {
     if true {
-        match path.strip_prefix(root_path) {
+        match path.strip_prefix(root_path)
+            .and(x) {
             Ok(rel_path) => {
                 Foo {
                     x: 1
@@ -1023,7 +1027,33 @@ fn main() {
     }
 }
 "#,
-        )
+        );
+
+        check_assist(
+            replace_if_let_with_match,
+            r#"
+fn main() {
+    if true {
+        $0if true
+            && false
+        {
+            foo()
+        }
+    }
+}
+"#,
+            r#"
+fn main() {
+    if true {
+        match true
+            && false {
+            true => foo(),
+            false => (),
+        }
+    }
+}
+"#,
+        );
     }
 
     #[test]
@@ -1878,7 +1908,9 @@ fn foo(x: Result<i32, ()>) {
             r#"
 fn main() {
     if true {
-        $0match path.strip_prefix(root_path) {
+        $0match path.strip_prefix(root_path)
+            .and(x)
+        {
             Ok(rel_path) => Foo {
                 x: 2
             }
@@ -1892,7 +1924,8 @@ fn main() {
             r#"
 fn main() {
     if true {
-        if let Ok(rel_path) = path.strip_prefix(root_path) {
+        if let Ok(rel_path) = path.strip_prefix(root_path)
+            .and(x) {
             Foo {
                 x: 2
             }
@@ -1911,7 +1944,9 @@ fn main() {
             r#"
 fn main() {
     if true {
-        $0match path.strip_prefix(root_path) {
+        $0match path.strip_prefix(root_path)
+            .and(x)
+        {
             Ok(rel_path) => {
                 let rel_path = RelativePathBuf::from_path(rel_path)
                     .ok()?;
@@ -1929,7 +1964,8 @@ fn main() {
             r#"
 fn main() {
     if true {
-        if let Ok(rel_path) = path.strip_prefix(root_path) {
+        if let Ok(rel_path) = path.strip_prefix(root_path)
+            .and(x) {
             let rel_path = RelativePathBuf::from_path(rel_path)
                 .ok()?;
             Some((*id, rel_path))

src/tools/rust-analyzer/crates/ide-completion/src/completions/pattern.rs

@@ -95,7 +95,7 @@ pub(crate) fn complete_pattern(
                     if refutable || single_variant_enum(variant.parent_enum(ctx.db)) =>
                 {
                     acc.add_variant_pat(ctx, pattern_ctx, None, variant, Some(name.clone()));
-                    true
+                    false
                 }
                 hir::ModuleDef::Adt(hir::Adt::Enum(e)) => refutable || single_variant_enum(e),
                 hir::ModuleDef::Const(..) => refutable,

src/tools/rust-analyzer/crates/ide-completion/src/tests/pattern.rs

@@ -122,7 +122,6 @@ fn foo() {
             st Record
             st Tuple
             st Unit
-            ev TupleV
             bn Record {…} Record { field$1 }$0
             bn Tuple(…)            Tuple($1)$0
             bn TupleV(…)          TupleV($1)$0
@@ -159,8 +158,6 @@ fn foo(foo: Foo) { match foo { Foo { x: $0 } } }
         expect![[r#"
             en Bar
             st Foo
-            ev Nil
-            ev Value
             bn Foo {…} Foo { x$1 }$0
             bn Nil             Nil$0
             bn Value         Value$0
@@ -189,7 +186,6 @@ fn foo() {
             st Record
             st Tuple
             st Unit
-            ev Variant
             bn Record {…} Record { field$1 }$0
             bn Tuple(…)            Tuple($1)$0
             bn Variant               Variant$0
@@ -354,6 +350,34 @@ fn func() {
     );
 }
 
+#[test]
+fn enum_unqualified() {
+    check_with_base_items(
+        r#"
+use Enum::*;
+fn func() {
+    if let $0 = unknown {}
+}
+"#,
+        expect![[r#"
+            ct CONST
+            en Enum
+            ma makro!(…)      macro_rules! makro
+            md module
+            st Record
+            st Tuple
+            st Unit
+            bn Record {…}   Record { field$1 }$0
+            bn RecordV {…} RecordV { field$1 }$0
+            bn Tuple(…)              Tuple($1)$0
+            bn TupleV(…)            TupleV($1)$0
+            bn UnitV                     UnitV$0
+            kw mut
+            kw ref
+        "#]],
+    );
+}
+
 #[test]
 fn completes_in_record_field_pat() {
     check(