Rollup merge of #149057 - lnicola:sync-from-ra, r=lnicola

`rust-analyzer` subtree update

Subtree update of `rust-analyzer` to rust-lang/rust-analyzer@afcfe14.

Created using https://github.com/rust-lang/josh-sync.

r? `@ghost`

Author: matthiaskrgr

src/tools/rust-analyzer/Cargo.lock

@@ -1,5 +1,5 @@
 [workspace]
-members = ["xtask/", "lib/*", "crates/*"]
+members = ["xtask/", "lib/*", "lib/ungrammar/ungrammar2json", "crates/*"]
 exclude = ["crates/proc-macro-srv/proc-macro-test/imp"]
 resolver = "2"
 
@@ -42,7 +42,7 @@ debug = 2
 # lsp-server = { path = "lib/lsp-server" }
 
 
-# ungrammar = { path = "../ungrammar" }
+# ungrammar = { path = "lin/ungrammar" }
 
 # salsa = { path = "../salsa" }
 # salsa-macros = { path = "../salsa/components/salsa-macros" }

src/tools/rust-analyzer/Cargo.toml

@@ -674,10 +674,13 @@ impl<'db> InferenceTable<'db> {
             let args = [ty, arg_ty];
             let trait_ref = TraitRef::new(self.interner(), fn_trait.into(), args);
 
+            let proj_args = self
+                .infer_ctxt
+                .fill_rest_fresh_args(output_assoc_type.into(), args.into_iter().map(Into::into));
             let projection = Ty::new_alias(
                 self.interner(),
                 rustc_type_ir::AliasTyKind::Projection,
-                AliasTy::new(self.interner(), output_assoc_type.into(), args),
+                AliasTy::new(self.interner(), output_assoc_type.into(), proj_args),
             );
 
             let pred = Predicate::upcast_from(trait_ref, self.interner());

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

@@ -524,3 +524,31 @@ fn g(it: *const (dyn Trait)) {
 "#,
     );
 }
+
+#[test]
+fn regression_20951() {
+    check_infer(
+        r#"
+//- minicore: async_fn
+trait DoesSomething {
+    fn do_something(&self) -> impl Future<Output = usize>;
+}
+
+impl<F> DoesSomething for F
+where
+    F: AsyncFn() -> usize,
+{
+    fn do_something(&self) -> impl Future<Output = usize> {
+        self()
+    }
+}
+"#,
+        expect![[r#"
+            43..47 'self': &'? Self
+            168..172 'self': &'? F
+            205..227 '{     ...     }': <F as AsyncFnMut<()>>::CallRefFuture<'<erased>>
+            215..219 'self': &'? F
+            215..221 'self()': <F as AsyncFnMut<()>>::CallRefFuture<'<erased>>
+        "#]],
+    );
+}

src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs

@@ -35,6 +35,9 @@ pub mod term_search;
 
 mod display;
 
+#[doc(hidden)]
+pub use hir_def::ModuleId;
+
 use std::{
     fmt,
     mem::discriminant,
@@ -48,8 +51,8 @@ use hir_def::{
     AdtId, AssocItemId, AssocItemLoc, AttrDefId, CallableDefId, ConstId, ConstParamId,
     CrateRootModuleId, DefWithBodyId, EnumId, EnumVariantId, ExternBlockId, ExternCrateId,
     FunctionId, GenericDefId, GenericParamId, HasModule, ImplId, ItemContainerId, LifetimeParamId,
-    LocalFieldId, Lookup, MacroExpander, MacroId, ModuleId, StaticId, StructId, SyntheticSyntax,
-    TupleId, TypeAliasId, TypeOrConstParamId, TypeParamId, UnionId,
+    LocalFieldId, Lookup, MacroExpander, MacroId, StaticId, StructId, SyntheticSyntax, TupleId,
+    TypeAliasId, TypeOrConstParamId, TypeParamId, UnionId,
     expr_store::{ExpressionStoreDiagnostics, ExpressionStoreSourceMap},
     hir::{
         BindingAnnotation, BindingId, Expr, ExprId, ExprOrPatId, LabelId, Pat,

src/tools/rust-analyzer/crates/hir/src/lib.rs

@@ -18,7 +18,7 @@ use hir_ty::{
 };
 use intern::Symbol;
 use rustc_hash::FxHashMap;
-use syntax::{AstNode, AstPtr, SmolStr, SyntaxNode, SyntaxNodePtr, ToSmolStr, ast::HasName};
+use syntax::{AstNode, AstPtr, SyntaxNode, SyntaxNodePtr, ToSmolStr, ast::HasName};
 
 use crate::{HasCrate, Module, ModuleDef, Semantics};
 
@@ -29,7 +29,7 @@ pub struct FileSymbol {
     pub name: Symbol,
     pub def: ModuleDef,
     pub loc: DeclarationLocation,
-    pub container_name: Option<SmolStr>,
+    pub container_name: Option<Symbol>,
     /// Whether this symbol is a doc alias for the original symbol.
     pub is_alias: bool,
     pub is_assoc: bool,
@@ -65,23 +65,29 @@ pub struct SymbolCollector<'a> {
     db: &'a dyn HirDatabase,
     symbols: FxIndexSet<FileSymbol>,
     work: Vec<SymbolCollectorWork>,
-    current_container_name: Option<SmolStr>,
+    current_container_name: Option<Symbol>,
+    collect_pub_only: bool,
 }
 
 /// Given a [`ModuleId`] and a [`HirDatabase`], use the DefMap for the module's crate to collect
 /// all symbols that should be indexed for the given module.
 impl<'a> SymbolCollector<'a> {
-    pub fn new(db: &'a dyn HirDatabase) -> Self {
+    pub fn new(db: &'a dyn HirDatabase, collect_pub_only: bool) -> Self {
         SymbolCollector {
             db,
             symbols: Default::default(),
             work: Default::default(),
             current_container_name: None,
+            collect_pub_only,
         }
     }
 
-    pub fn new_module(db: &dyn HirDatabase, module: Module) -> Box<[FileSymbol]> {
-        let mut symbol_collector = SymbolCollector::new(db);
+    pub fn new_module(
+        db: &dyn HirDatabase,
+        module: Module,
+        collect_pub_only: bool,
+    ) -> Box<[FileSymbol]> {
+        let mut symbol_collector = SymbolCollector::new(db, collect_pub_only);
         symbol_collector.collect(module);
         symbol_collector.finish()
     }
@@ -108,12 +114,16 @@ impl<'a> SymbolCollector<'a> {
         tracing::info!(?work, "SymbolCollector::do_work");
         self.db.unwind_if_revision_cancelled();
 
-        let parent_name = work.parent.map(|name| name.as_str().to_smolstr());
+        let parent_name = work.parent.map(|name| Symbol::intern(name.as_str()));
         self.with_container_name(parent_name, |s| s.collect_from_module(work.module_id));
     }
 
     fn collect_from_module(&mut self, module_id: ModuleId) {
-        let push_decl = |this: &mut Self, def, name| {
+        let collect_pub_only = self.collect_pub_only;
+        let push_decl = |this: &mut Self, def: ModuleDefId, name, vis| {
+            if collect_pub_only && vis != Visibility::Public {
+                return;
+            }
             match def {
                 ModuleDefId::ModuleId(id) => this.push_module(id, name),
                 ModuleDefId::FunctionId(id) => {
@@ -125,7 +135,7 @@ impl<'a> SymbolCollector<'a> {
                 }
                 ModuleDefId::AdtId(AdtId::EnumId(id)) => {
                     this.push_decl(id, name, false, None);
-                    let enum_name = this.db.enum_signature(id).name.as_str().to_smolstr();
+                    let enum_name = Symbol::intern(this.db.enum_signature(id).name.as_str());
                     this.with_container_name(Some(enum_name), |this| {
                         let variants = id.enum_variants(this.db);
                         for (variant_id, variant_name, _) in &variants.variants {
@@ -175,6 +185,9 @@ impl<'a> SymbolCollector<'a> {
         };
 
         let mut push_import = |this: &mut Self, i: ImportId, name: &Name, def: ModuleDefId, vis| {
+            if collect_pub_only && vis != Visibility::Public {
+                return;
+            }
             let source = import_child_source_cache
                 .entry(i.use_)
                 .or_insert_with(|| i.use_.child_source(this.db));
@@ -209,6 +222,9 @@ impl<'a> SymbolCollector<'a> {
 
         let push_extern_crate =
             |this: &mut Self, i: ExternCrateId, name: &Name, def: ModuleDefId, vis| {
+                if collect_pub_only && vis != Visibility::Public {
+                    return;
+                }
                 let loc = i.lookup(this.db);
                 let source = loc.source(this.db);
                 let rename = source.value.rename().and_then(|rename| rename.name());
@@ -258,7 +274,7 @@ impl<'a> SymbolCollector<'a> {
                 continue;
             }
             // self is a declaration
-            push_decl(self, def, name)
+            push_decl(self, def, name, vis)
         }
 
         for (name, Item { def, vis, import }) in scope.macros() {
@@ -271,7 +287,7 @@ impl<'a> SymbolCollector<'a> {
                 continue;
             }
             // self is a declaration
-            push_decl(self, def.into(), name)
+            push_decl(self, ModuleDefId::MacroId(def), name, vis)
         }
 
         for (name, Item { def, vis, import }) in scope.values() {
@@ -283,7 +299,7 @@ impl<'a> SymbolCollector<'a> {
                 continue;
             }
             // self is a declaration
-            push_decl(self, def, name)
+            push_decl(self, def, name, vis)
         }
 
         for const_id in scope.unnamed_consts() {
@@ -304,6 +320,9 @@ impl<'a> SymbolCollector<'a> {
     }
 
     fn collect_from_body(&mut self, body_id: impl Into<DefWithBodyId>, name: Option<Name>) {
+        if self.collect_pub_only {
+            return;
+        }
         let body_id = body_id.into();
         let body = self.db.body(body_id);
 
@@ -328,23 +347,28 @@ impl<'a> SymbolCollector<'a> {
                 )
                 .to_smolstr(),
         );
-        self.with_container_name(impl_name, |s| {
+        self.with_container_name(impl_name.as_deref().map(Symbol::intern), |s| {
             for &(ref name, assoc_item_id) in &impl_id.impl_items(self.db).items {
+                if s.collect_pub_only && s.db.assoc_visibility(assoc_item_id) != Visibility::Public
+                {
+                    continue;
+                }
+
                 s.push_assoc_item(assoc_item_id, name, None)
             }
         })
     }
 
     fn collect_from_trait(&mut self, trait_id: TraitId, trait_do_not_complete: Complete) {
         let trait_data = self.db.trait_signature(trait_id);
-        self.with_container_name(Some(trait_data.name.as_str().into()), |s| {
+        self.with_container_name(Some(Symbol::intern(trait_data.name.as_str())), |s| {
             for &(ref name, assoc_item_id) in &trait_id.trait_items(self.db).items {
                 s.push_assoc_item(assoc_item_id, name, Some(trait_do_not_complete));
             }
         });
     }
 
-    fn with_container_name(&mut self, container_name: Option<SmolStr>, f: impl FnOnce(&mut Self)) {
+    fn with_container_name(&mut self, container_name: Option<Symbol>, f: impl FnOnce(&mut Self)) {
         if let Some(container_name) = container_name {
             let prev = self.current_container_name.replace(container_name);
             f(self);

src/tools/rust-analyzer/crates/hir/src/symbols.rs

@@ -1,7 +1,14 @@
-use ide_db::syntax_helpers::node_ext::for_each_break_and_continue_expr;
+use ide_db::{
+    source_change::SourceChangeBuilder, syntax_helpers::node_ext::for_each_break_and_continue_expr,
+};
 use syntax::{
-    T,
-    ast::{self, AstNode, HasLoopBody},
+    SyntaxToken, T,
+    ast::{
+        self, AstNode, HasLoopBody,
+        make::{self, tokens},
+        syntax_factory::SyntaxFactory,
+    },
+    syntax_editor::{Position, SyntaxEditor},
 };
 
 use crate::{AssistContext, AssistId, Assists};
@@ -21,9 +28,9 @@ use crate::{AssistContext, AssistId, Assists};
 // ->
 // ```
 // fn main() {
-//     'l: loop {
-//         break 'l;
-//         continue 'l;
+//     ${1:'l}: loop {
+//         break ${2:'l};
+//         continue ${0:'l};
 //     }
 // }
 // ```
@@ -39,30 +46,56 @@ pub(crate) fn add_label_to_loop(acc: &mut Assists, ctx: &AssistContext<'_>) -> O
         "Add Label",
         loop_expr.syntax().text_range(),
         |builder| {
-            builder.insert(loop_kw.text_range().start(), "'l: ");
+            let make = SyntaxFactory::with_mappings();
+            let mut editor = builder.make_editor(loop_expr.syntax());
+
+            let label = make.lifetime("'l");
+            let elements = vec![
+                label.syntax().clone().into(),
+                make::token(T![:]).into(),
+                tokens::single_space().into(),
+            ];
+            editor.insert_all(Position::before(&loop_kw), elements);
+
+            if let Some(cap) = ctx.config.snippet_cap {
+                editor.add_annotation(label.syntax(), builder.make_placeholder_snippet(cap));
+            }
 
             let loop_body = loop_expr.loop_body().and_then(|it| it.stmt_list());
-            for_each_break_and_continue_expr(
-                loop_expr.label(),
-                loop_body,
-                &mut |expr| match expr {
-                    ast::Expr::BreakExpr(break_expr) => {
-                        if let Some(break_token) = break_expr.break_token() {
-                            builder.insert(break_token.text_range().end(), " 'l")
-                        }
-                    }
-                    ast::Expr::ContinueExpr(continue_expr) => {
-                        if let Some(continue_token) = continue_expr.continue_token() {
-                            builder.insert(continue_token.text_range().end(), " 'l")
-                        }
-                    }
-                    _ => {}
-                },
-            );
+            for_each_break_and_continue_expr(loop_expr.label(), loop_body, &mut |expr| {
+                let token = match expr {
+                    ast::Expr::BreakExpr(break_expr) => break_expr.break_token(),
+                    ast::Expr::ContinueExpr(continue_expr) => continue_expr.continue_token(),
+                    _ => return,
+                };
+                if let Some(token) = token {
+                    insert_label_after_token(&mut editor, &make, &token, ctx, builder);
+                }
+            });
+
+            editor.add_mappings(make.finish_with_mappings());
+            builder.add_file_edits(ctx.vfs_file_id(), editor);
+            builder.rename();
         },
     )
 }
 
+fn insert_label_after_token(
+    editor: &mut SyntaxEditor,
+    make: &SyntaxFactory,
+    token: &SyntaxToken,
+    ctx: &AssistContext<'_>,
+    builder: &mut SourceChangeBuilder,
+) {
+    let label = make.lifetime("'l");
+    let elements = vec![tokens::single_space().into(), label.syntax().clone().into()];
+    editor.insert_all(Position::after(token), elements);
+
+    if let Some(cap) = ctx.config.snippet_cap {
+        editor.add_annotation(label.syntax(), builder.make_placeholder_snippet(cap));
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::tests::{check_assist, check_assist_not_applicable};
@@ -82,9 +115,9 @@ fn main() {
 }"#,
             r#"
 fn main() {
-    'l: loop {
-        break 'l;
-        continue 'l;
+    ${1:'l}: loop {
+        break ${2:'l};
+        continue ${0:'l};
     }
 }"#,
         );
@@ -107,9 +140,9 @@ fn main() {
 }"#,
             r#"
 fn main() {
-    'l: loop {
-        break 'l;
-        continue 'l;
+    ${1:'l}: loop {
+        break ${2:'l};
+        continue ${0:'l};
         loop {
             break;
             continue;
@@ -139,9 +172,9 @@ fn main() {
     loop {
         break;
         continue;
-        'l: loop {
-            break 'l;
-            continue 'l;
+        ${1:'l}: loop {
+            break ${2:'l};
+            continue ${0:'l};
         }
     }
 }"#,