rust-analyzer subtree update

src/tools/rust-analyzer/.github/workflows/gen-lints.yml

@@ -11,6 +11,7 @@ defaults:
 
 jobs:
   lints-gen:
+    if: ${{ github.repository == 'rust-lang/rust-analyzer' || github.event_name == 'workflow_dispatch' }}
     name: Generate lints
     runs-on: ubuntu-latest
     permissions:

src/tools/rust-analyzer/Cargo.lock

@@ -1889,6 +1889,7 @@ dependencies = [
  "line-index 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "paths",
  "proc-macro-test",
+ "rustc-hash 2.1.2",
  "span",
  "stdx",
 ]

src/tools/rust-analyzer/clippy.toml

@@ -1,9 +1,9 @@
 disallowed-types = [
-    { path = "std::collections::HashMap", reason = "use FxHashMap" },
-    { path = "std::collections::HashSet", reason = "use FxHashSet" },
-    { path = "std::collections::hash_map::RandomState", reason = "use BuildHasherDefault<FxHasher>"}
+    { path = "std::collections::HashMap", replacement = "rustc_hash::FxHashMap" },
+    { path = "std::collections::HashSet", replacement = "rustc_hash::FxHashSet" },
+    { path = "std::collections::hash_map::RandomState", replacement = "std::hash::BuildHasherDefault<FxHasher>"}
 ]
 
 disallowed-methods = [
-    { path = "std::process::Command::new", reason = "use `toolchain::command` instead as it forces the choice of a working directory" },
+    { path = "std::process::Command::new", replacement = "toolchain::command", reason = "the latter forces the choice of a working directory" },
 ]

src/tools/rust-analyzer/crates/base-db/src/input.rs

@@ -8,6 +8,7 @@
 
 use std::error::Error;
 use std::hash::BuildHasherDefault;
+use std::str::FromStr;
 use std::{fmt, mem, ops};
 
 use cfg::{CfgOptions, HashableCfgOptions};
@@ -315,14 +316,17 @@ impl ReleaseChannel {
             ReleaseChannel::Nightly => "nightly",
         }
     }
+}
+
+impl FromStr for ReleaseChannel {
+    type Err = ();
 
-    #[allow(clippy::should_implement_trait)]
-    pub fn from_str(str: &str) -> Option<Self> {
-        Some(match str {
+    fn from_str(str: &str) -> Result<Self, Self::Err> {
+        Ok(match str {
             "" | "stable" => ReleaseChannel::Stable,
             "nightly" => ReleaseChannel::Nightly,
             _ if str.starts_with("beta") => ReleaseChannel::Beta,
-            _ => return None,
+            _ => return Err(()),
         })
     }
 }

src/tools/rust-analyzer/crates/base-db/src/lib.rs

@@ -19,6 +19,7 @@ use std::{
     cell::RefCell,
     hash::BuildHasherDefault,
     panic,
+    str::FromStr as _,
     sync::{Once, atomic::AtomicUsize},
 };
 
@@ -327,7 +328,7 @@ impl CrateWorkspaceData {
 }
 
 pub fn toolchain_channel(db: &dyn salsa::Database, krate: Crate) -> Option<ReleaseChannel> {
-    krate.workspace_data(db).toolchain.as_ref().and_then(|v| ReleaseChannel::from_str(&v.pre))
+    krate.workspace_data(db).toolchain.as_ref().and_then(|v| ReleaseChannel::from_str(&v.pre).ok())
 }
 
 #[salsa::input(singleton, debug)]

src/tools/rust-analyzer/crates/hir-def/src/attrs/docs.rs

@@ -608,6 +608,7 @@ fn expand_doc_macro_call<'db>(
         ExpandTo::Expr,
         expander.krate,
         expander.macro_depth + 1,
+        expander.recursion_limit,
         |path| {
             expander.resolver.resolve_path_as_macro_def(expander.db, path, Some(MacroSubNs::Bang))
         },

src/tools/rust-analyzer/crates/hir-def/src/dyn_map.rs

@@ -119,10 +119,6 @@ pub struct Key<K, V, P = (K, V)> {
 }
 
 impl<K, V, P> Key<K, V, P> {
-    #[allow(
-        clippy::new_without_default,
-        reason = "this a const fn, so it can't be default yet. See <https://github.com/rust-lang/rust/issues/63065>"
-    )]
     pub(crate) const fn new() -> Key<K, V, P> {
         Key { _phantom: PhantomData }
     }

src/tools/rust-analyzer/crates/hir-def/src/expr_store.rs

@@ -624,7 +624,6 @@ impl ExpressionStore {
                 visitor.on_expr_opt(*end);
             }
             Pat::Lit(expr) | Pat::Expr(expr) => visitor.on_expr(*expr),
-            Pat::ConstBlock(expr) => visitor.on_anon_const_expr(*expr),
             Pat::Path(path) => visitor.on_path(path),
             Pat::Wild | Pat::Missing | Pat::Rest | Pat::NotNull => {}
             &Pat::Bind { subpat, id: _ } => visitor.on_pat_opt(subpat),

src/tools/rust-analyzer/crates/hir-def/src/expr_store/expander.rs

@@ -111,7 +111,8 @@ impl<'db> Expander<'db> {
                 call_site.ctx,
                 expands_to,
                 krate,
-                this.macro_depth,
+                this.macro_depth + 1,
+                this.recursion_limit,
                 |path| resolver(path).map(|it| it.definition(db)),
                 eager_callback,
             ) {

src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs

@@ -3082,16 +3082,7 @@ impl<'db> ExprCollector<'db> {
                 Pat::Deref { inner }
             }
             ast::Pat::NotNull(_) => Pat::NotNull,
-            ast::Pat::ConstBlockPat(const_block_pat) => {
-                if let Some(block) = const_block_pat.block_expr() {
-                    let expr_id = self.with_label_rib(RibKind::Constant, |this| {
-                        this.with_binding_owner(|this| this.collect_block(block))
-                    });
-                    Pat::ConstBlock(expr_id)
-                } else {
-                    Pat::Missing
-                }
-            }
+            ast::Pat::ConstBlockPat(_) => Pat::Missing,
             ast::Pat::MacroPat(mac) => {
                 return self.collect_macro_pat_with(mac.clone(), |this, expanded_pat| {
                     this.collect_pat(expanded_pat, binding_list)
@@ -3277,16 +3268,6 @@ impl<'db> ExprCollector<'db> {
                 let Some((literal, _)) = pat_literal_to_hir(it) else { return self.missing_expr() };
                 self.alloc_expr_from_pat(Expr::Literal(literal), ptr)
             }
-            ast::Pat::ConstBlockPat(it) => {
-                if let Some(block) = it.block_expr() {
-                    let expr_id = self.with_label_rib(RibKind::Constant, |this| {
-                        this.with_binding_owner(|this| this.collect_block(block))
-                    });
-                    self.alloc_expr_from_pat(Expr::Const(expr_id), ptr)
-                } else {
-                    self.missing_expr()
-                }
-            }
             ast::Pat::PathPat(it) => {
                 let path = it
                     .path()

src/tools/rust-analyzer/crates/hir-def/src/expr_store/pretty.rs

@@ -1033,10 +1033,6 @@ impl Printer<'_> {
                 self.print_pat(*inner);
                 w!(self, ")");
             }
-            Pat::ConstBlock(c) => {
-                w!(self, "const ");
-                self.print_expr(*c);
-            }
             Pat::Expr(expr) => {
                 self.print_expr_in(prec, *expr);
             }

src/tools/rust-analyzer/crates/hir-def/src/expr_store/scope.rs

@@ -115,7 +115,10 @@ impl ExprScopes {
     }
 
     /// If `scope` refers to a macro def scope, returns the corresponding `MacroId`.
-    #[allow(clippy::borrowed_box)] // If we return `&MacroDefId` we need to move it, this way we just clone the `Box`.
+    #[expect(
+        clippy::borrowed_box,
+        reason = "If we return `&MacroDefId` we need to move it, this way we just clone the `Box`."
+    )]
     pub fn macro_def(&self, scope: ScopeId) -> Option<&Box<MacroDefId>> {
         match &self.scopes[scope].kind {
             ScopeKind::MacroDef(macro_def) => Some(macro_def),
@@ -818,66 +821,4 @@ fn test() {
             100,
         );
     }
-    #[test]
-    fn pattern_const_block_expressions_have_scopes() {
-        do_check(
-            r#"
-fn foo() {
-    match () {
-        const { |x: i32| { let y = x; $0 } } => (),
-    }
-}
-"#,
-            &["y", "x"],
-        );
-    }
-
-    #[test]
-    fn let_pattern_expr_scope() {
-        do_check(
-            r#"
-fn foo(param: usize) {
-    let local = 0;
-    let const { $0 } = ();
-}
-"#,
-            &["param"],
-        );
-    }
-
-    #[test]
-    fn closure_param_pattern_expr_scope() {
-        do_check(
-            r#"
-fn foo(param: usize) {
-    let local = 0;
-    let _ = |const { $0 }: ()| ();
-}
-"#,
-            &["param"],
-        );
-    }
-
-    #[test]
-    fn fn_param_pattern_expr_scope() {
-        do_check(
-            r#"
-fn foo(param: usize, const { $0 }: ()) {}
-"#,
-            &["param"],
-        );
-    }
-
-    #[test]
-    fn if_let_pattern_expr_scope() {
-        do_check(
-            r#"
-fn foo(param: usize) {
-    let local = 0;
-    if let const { $0 } = () {}
-}
-"#,
-            &["param"],
-        );
-    }
 }

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

@@ -800,7 +800,6 @@ pub enum Pat {
         inner: PatId,
     },
     NotNull,
-    ConstBlock(ExprId),
     /// An expression inside a pattern. That can only occur inside assignments.
     ///
     /// E.g. in `(a, *b) = (1, &mut 2)`, `*b` is an expression.
@@ -813,7 +812,6 @@ impl Pat {
             Pat::Range { .. }
             | Pat::Lit(..)
             | Pat::Path(..)
-            | Pat::ConstBlock(..)
             | Pat::Wild
             | Pat::Missing
             | Pat::Rest

src/tools/rust-analyzer/crates/hir-def/src/hir/format_args.rs

@@ -169,7 +169,6 @@ enum PositionUsedAs {
 }
 use PositionUsedAs::*;
 
-#[allow(clippy::unnecessary_lazy_evaluations)]
 pub(crate) fn parse(
     s: &ast::String,
     string_ptr: AstPtr<ast::Expr>,

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

@@ -1442,6 +1442,7 @@ pub fn macro_call_as_call_id(
     expand_to: ExpandTo,
     krate: Crate,
     macro_depth: u32,
+    recursion_limit: u32,
     resolver: impl Fn(&ModPath) -> Option<MacroDefId> + Copy,
     eager_callback: &mut dyn FnMut(
         InFile<(syntax::AstPtr<ast::MacroCall>, span::FileAstId<ast::MacroCall>)>,
@@ -1459,6 +1460,7 @@ pub fn macro_call_as_call_id(
             def,
             call_site,
             macro_depth,
+            recursion_limit,
             &|path| resolver(path).filter(MacroDefId::is_fn_like),
             eager_callback,
         ),

src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/builtin_fn_macro.rs

@@ -628,3 +628,34 @@ const _: bool = foo::<(), fn() -> Foo<i32, i64>>(1, );
     "#]],
     );
 }
+
+#[test]
+fn eager_recursion_limit() {
+    check(
+        r#"
+//- minicore: concat
+
+macro_rules! concat_separator {
+    () => {
+        concat!("", concat_separator!())
+    };
+}
+
+fn main() {
+    concat_separator!()
+}
+    "#,
+        expect![[r#"
+
+macro_rules! concat_separator {
+    () => {
+        concat!("", concat_separator!())
+    };
+}
+
+fn main() {
+    concat!("", concat_separator!())
+}
+    "#]],
+    );
+}

src/tools/rust-analyzer/crates/hir-def/src/nameres/assoc.rs

@@ -323,6 +323,7 @@ impl<'db> AssocItemCollector<'db> {
                     ExpandTo::Items,
                     self.module_id.krate(self.db),
                     self.macro_depth + 1,
+                    self.def_map.recursion_limit(),
                     resolver,
                     &mut |ptr, call_id| {
                         self.macro_calls.push((ptr.map(|(_, it)| it.upcast()), call_id))

src/tools/rust-analyzer/crates/hir-def/src/nameres/collector.rs

@@ -1360,6 +1360,7 @@ impl<'db> DefCollector<'db> {
                         *expand_to,
                         self.def_map.krate,
                         directive.depth,
+                        self.def_map.recursion_limit(),
                         resolver_def_id,
                         &mut |ptr, call_id| {
                             eager_callback_buffer.push((directive.module_id, ptr, call_id));
@@ -1793,6 +1794,7 @@ impl<'db> DefCollector<'db> {
                         *expand_to,
                         self.def_map.krate,
                         directive.depth,
+                        self.def_map.recursion_limit(),
                         |path| {
                             let resolved_res = self.def_map.resolve_path_fp_with_macro(
                                 self.crate_local_def_map.unwrap_or(&self.local_def_map),
@@ -2698,6 +2700,7 @@ impl ModCollector<'_, '_> {
             expand_to,
             self.def_collector.def_map.krate,
             self.macro_depth + 1,
+            self.def_collector.def_map.recursion_limit(),
             |path| {
                 path.as_ident().and_then(|name| {
                     let def_map = &self.def_collector.def_map;

src/tools/rust-analyzer/crates/hir-expand/src/builtin/quote.rs

@@ -1,5 +1,4 @@
 //! A simplified version of quote-crate like quasi quote macro
-#![allow(clippy::crate_in_macro_def)]
 
 use intern::{Symbol, sym};
 use span::Span;
@@ -185,7 +184,7 @@ macro_rules! impl_to_to_tokentrees {
         $(
             impl ToTokenTree for $ty {
                 fn to_tokens($this, $span: Span, builder: &mut TopSubtreeBuilder) {
-                    let leaf: crate::tt::Leaf = $im.into();
+                    let leaf: $crate::tt::Leaf = $im.into();
                     builder.push(leaf);
                 }
             }