Auto merge of #152739 - Zalathar:rollup-8qaJ8F2, r=Zalathar

Rollup of 11 pull requests

Successful merges:

 - rust-lang/rust#152700 (miri subtree update)
 - rust-lang/rust#152715 (`rust-analyzer` subtree update)
 - rust-lang/rust#151783 (Implement RFC 3678: Final trait methods)
 - rust-lang/rust#152512 (core: Implement feature `float_exact_integer_constants`)
 - rust-lang/rust#152661 (Avoid ICE in From/TryFrom diagnostic under -Znext-solver)
 - rust-lang/rust#152703 (Remove `rustc_query_system`)
 - rust-lang/rust#152206 (misc doc improvements)
 - rust-lang/rust#152664 (Fix mis-constructed `file_span` when generating scraped examples)
 - rust-lang/rust#152698 (Suppress unstable-trait notes under `-Zforce-unstable-if-unmarked`)
 - rust-lang/rust#152727 (`probe_op` silence ambiguity errors if tainted)
 - rust-lang/rust#152728 (Port #![default_lib_allocator] to the new attribute parser)

Author: bors

.github/workflows/ci.yaml

@@ -96,7 +96,7 @@ jobs:
         run: |
           rustup update --no-self-update stable
           rustup default stable
-          rustup component add --toolchain stable rust-src clippy rustfmt
+          rustup component add --toolchain stable rust-src rustfmt
           # We also install a nightly rustfmt, because we use `--file-lines` in
           # a test.
           rustup toolchain install nightly --profile minimal --component rustfmt
@@ -128,10 +128,6 @@ jobs:
       - name: Run cargo-machete
         run: cargo machete
 
-      - name: Run Clippy
-        if: matrix.os == 'macos-latest'
-        run: cargo clippy --all-targets -- -D clippy::disallowed_macros -D clippy::dbg_macro -D clippy::todo -D clippy::print_stdout -D clippy::print_stderr
-
   analysis-stats:
     if: github.repository == 'rust-lang/rust-analyzer'
     runs-on: ubuntu-latest
@@ -178,6 +174,28 @@ jobs:
 
       - run: cargo fmt -- --check
 
+  clippy:
+    if: github.repository == 'rust-lang/rust-analyzer'
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      # Note that clippy output is currently dependent on whether rust-src is installed,
+      # https://github.com/rust-lang/rust-clippy/issues/14625
+      - name: Install Rust toolchain
+        run: |
+          rustup update --no-self-update stable
+          rustup default stable
+          rustup component add --toolchain stable rust-src clippy
+
+      # https://github.com/actions-rust-lang/setup-rust-toolchain/blob/main/rust.json
+      - name: Install Rust Problem Matcher
+        run: echo "::add-matcher::.github/rust.json"
+
+      - run: cargo clippy --all-targets -- -D clippy::disallowed_macros -D clippy::dbg_macro -D clippy::todo -D clippy::print_stdout -D clippy::print_stderr
+
   miri:
     if: github.repository == 'rust-lang/rust-analyzer'
     runs-on: ubuntu-latest
@@ -188,8 +206,11 @@ jobs:
 
       - name: Install Rust toolchain
         run: |
-          rustup update --no-self-update nightly
-          rustup default nightly
+          # FIXME: Pin nightly due to a regression in miri on nightly-2026-02-12.
+          # See https://github.com/rust-lang/miri/issues/4855.
+          # Revert to plain `nightly` once this is fixed upstream.
+          rustup toolchain install nightly-2026-02-10
+          rustup default nightly-2026-02-10
           rustup component add miri
 
       # - name: Cache Dependencies
@@ -309,7 +330,7 @@ jobs:
         run: typos
 
   conclusion:
-    needs: [rust, rust-cross, typescript, typo-check, proc-macro-srv, miri, rustfmt, analysis-stats]
+    needs: [rust, rust-cross, typescript, typo-check, proc-macro-srv, miri, rustfmt, clippy, analysis-stats]
     # We need to ensure this job does *not* get skipped if its dependencies fail,
     # because a skipped job is considered a success by GitHub. So we have to
     # overwrite `if:`. We use `!cancelled()` to ensure the job does still not get run

Cargo.lock

@@ -135,13 +135,13 @@ rayon = "1.10.0"
 rowan = "=0.15.17"
 # Ideally we'd not enable the macros feature but unfortunately the `tracked` attribute does not work
 # on impls without it
-salsa = { version = "0.26", default-features = false, features = [
+salsa = { version = "0.25.2", default-features = false, features = [
     "rayon",
     "salsa_unstable",
     "macros",
     "inventory",
 ] }
-salsa-macros = "0.26"
+salsa-macros = "0.25.2"
 semver = "1.0.26"
 serde = { version = "1.0.219" }
 serde_derive = { version = "1.0.219" }

Cargo.toml

@@ -60,7 +60,7 @@ const _: () = {
         }
     }
 
-    impl zalsa_::HashEqLike<WithoutCrate> for EditionedFileIdData {
+    impl zalsa_struct_::HashEqLike<WithoutCrate> for EditionedFileIdData {
         #[inline]
         fn hash<H: Hasher>(&self, state: &mut H) {
             Hash::hash(self, state);

crates/base-db/src/editioned_file_id.rs

@@ -32,8 +32,8 @@ use triomphe::Arc;
 use tt::TextRange;
 
 use crate::{
-    AdtId, BlockId, BlockLoc, DefWithBodyId, FunctionId, GenericDefId, ImplId, MacroId,
-    ModuleDefId, ModuleId, TraitId, TypeAliasId, UnresolvedMacro,
+    AdtId, BlockId, BlockLoc, DefWithBodyId, FunctionId, GenericDefId, ImplId, ItemContainerId,
+    MacroId, ModuleDefId, ModuleId, TraitId, TypeAliasId, UnresolvedMacro,
     attrs::AttrFlags,
     db::DefDatabase,
     expr_store::{
@@ -141,9 +141,19 @@ pub(super) fn lower_body(
             source_map_self_param = Some(collector.expander.in_file(AstPtr::new(&self_param_syn)));
         }
 
+        let is_extern = matches!(
+            owner,
+            DefWithBodyId::FunctionId(id)
+                if matches!(id.loc(db).container, ItemContainerId::ExternBlockId(_)),
+        );
+
         for param in param_list.params() {
             if collector.check_cfg(&param) {
-                let param_pat = collector.collect_pat_top(param.pat());
+                let param_pat = if is_extern {
+                    collector.collect_extern_fn_param(param.pat())
+                } else {
+                    collector.collect_pat_top(param.pat())
+                };
                 params.push(param_pat);
             }
         }
@@ -2248,6 +2258,32 @@ impl<'db> ExprCollector<'db> {
         }
     }
 
+    fn collect_extern_fn_param(&mut self, pat: Option<ast::Pat>) -> PatId {
+        // `extern` functions cannot have pattern-matched parameters, and furthermore, the identifiers
+        // in their parameters are always interpreted as bindings, even if in a normal function they
+        // won't be, because they would refer to a path pattern.
+        let Some(pat) = pat else { return self.missing_pat() };
+
+        match &pat {
+            ast::Pat::IdentPat(bp) => {
+                // FIXME: Emit an error if `!bp.is_simple_ident()`.
+
+                let name = bp.name().map(|nr| nr.as_name()).unwrap_or_else(Name::missing);
+                let hygiene = bp
+                    .name()
+                    .map(|name| self.hygiene_id_for(name.syntax().text_range()))
+                    .unwrap_or(HygieneId::ROOT);
+                let binding = self.alloc_binding(name, BindingAnnotation::Unannotated, hygiene);
+                let pat =
+                    self.alloc_pat(Pat::Bind { id: binding, subpat: None }, AstPtr::new(&pat));
+                self.add_definition_to_binding(binding, pat);
+                pat
+            }
+            // FIXME: Emit an error.
+            _ => self.missing_pat(),
+        }
+    }
+
     // region: patterns
 
     fn collect_pat_top(&mut self, pat: Option<ast::Pat>) -> PatId {

crates/hir-def/src/expr_store/lower.rs

@@ -483,6 +483,11 @@ impl ItemScope {
         self.declarations.push(def)
     }
 
+    pub(crate) fn remove_from_value_ns(&mut self, name: &Name, def: ModuleDefId) {
+        let entry = self.values.shift_remove(name);
+        assert!(entry.is_some_and(|entry| entry.def == def))
+    }
+
     pub(crate) fn get_legacy_macro(&self, name: &Name) -> Option<&[MacroId]> {
         self.legacy_macros.get(name).map(|it| &**it)
     }

crates/hir-def/src/item_scope.rs

@@ -211,6 +211,7 @@ struct DefMapCrateData {
     /// Side table for resolving derive helpers.
     exported_derives: FxHashMap<MacroId, Box<[Name]>>,
     fn_proc_macro_mapping: FxHashMap<FunctionId, ProcMacroId>,
+    fn_proc_macro_mapping_back: FxHashMap<ProcMacroId, FunctionId>,
 
     /// Custom tool modules registered with `#![register_tool]`.
     registered_tools: Vec<Symbol>,
@@ -230,6 +231,7 @@ impl DefMapCrateData {
         Self {
             exported_derives: FxHashMap::default(),
             fn_proc_macro_mapping: FxHashMap::default(),
+            fn_proc_macro_mapping_back: FxHashMap::default(),
             registered_tools: PREDEFINED_TOOLS.iter().map(|it| Symbol::intern(it)).collect(),
             unstable_features: FxHashSet::default(),
             rustc_coherence_is_core: false,
@@ -244,6 +246,7 @@ impl DefMapCrateData {
         let Self {
             exported_derives,
             fn_proc_macro_mapping,
+            fn_proc_macro_mapping_back,
             registered_tools,
             unstable_features,
             rustc_coherence_is_core: _,
@@ -254,6 +257,7 @@ impl DefMapCrateData {
         } = self;
         exported_derives.shrink_to_fit();
         fn_proc_macro_mapping.shrink_to_fit();
+        fn_proc_macro_mapping_back.shrink_to_fit();
         registered_tools.shrink_to_fit();
         unstable_features.shrink_to_fit();
     }
@@ -570,6 +574,10 @@ impl DefMap {
         self.data.fn_proc_macro_mapping.get(&id).copied()
     }
 
+    pub fn proc_macro_as_fn(&self, id: ProcMacroId) -> Option<FunctionId> {
+        self.data.fn_proc_macro_mapping_back.get(&id).copied()
+    }
+
     pub fn krate(&self) -> Crate {
         self.krate
     }

crates/hir-def/src/nameres.rs

@@ -634,6 +634,7 @@ impl<'db> DefCollector<'db> {
             crate_data.exported_derives.insert(proc_macro_id.into(), helpers);
         }
         crate_data.fn_proc_macro_mapping.insert(fn_id, proc_macro_id);
+        crate_data.fn_proc_macro_mapping_back.insert(proc_macro_id, fn_id);
     }
 
     /// Define a macro with `macro_rules`.
@@ -2095,6 +2096,8 @@ impl ModCollector<'_, '_> {
 
                     let vis = resolve_vis(def_map, local_def_map, &self.item_tree[it.visibility]);
 
+                    update_def(self.def_collector, fn_id.into(), &it.name, vis, false);
+
                     if self.def_collector.def_map.block.is_none()
                         && self.def_collector.is_proc_macro
                         && self.module_id == self.def_collector.def_map.root
@@ -2105,9 +2108,14 @@ impl ModCollector<'_, '_> {
                             InFile::new(self.file_id(), id),
                             fn_id,
                         );
-                    }
 
-                    update_def(self.def_collector, fn_id.into(), &it.name, vis, false);
+                        // A proc macro is implemented as a function, but it's treated as a macro, not a function.
+                        // You cannot call it like a function, for example, except in its defining crate.
+                        // So we keep the function definition, but remove it from the scope, leaving only the macro.
+                        self.def_collector.def_map[module_id]
+                            .scope
+                            .remove_from_value_ns(&it.name, fn_id.into());
+                    }
                 }
                 ModItemId::Struct(id) => {
                     let it = &self.item_tree[id];

crates/hir-def/src/nameres/collector.rs

@@ -1068,10 +1068,8 @@ pub fn derive_macro_2(_item: TokenStream) -> TokenStream {
             - AnotherTrait : macro#
             - DummyTrait : macro#
             - TokenStream : type value
-            - attribute_macro : value macro#
-            - derive_macro : value
-            - derive_macro_2 : value
-            - function_like_macro : value macro!
+            - attribute_macro : macro#
+            - function_like_macro : macro!
         "#]],
     );
 }