Auto merge of #154007 - JonathanBrouwer:rollup-WcvGVsy, r=<try>

Rollup of 8 pull requests


try-job: test-various
try-job: x86_64-gnu-aux
try-job: x86_64-gnu-llvm-21-3
try-job: x86_64-msvc-1
try-job: aarch64-apple
try-job: x86_64-mingw-1

Author: bors

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -1487,6 +1487,15 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                     ident,
                     sig,
                 );
+
+                if let Some(attr) = attr::find_by_name(fi.attrs(), sym::track_caller)
+                    && self.extern_mod_abi != Some(ExternAbi::Rust)
+                {
+                    self.dcx().emit_err(errors::RequiresRustAbi {
+                        track_caller_span: attr.span,
+                        extern_abi_span: self.current_extern_span(),
+                    });
+                }
             }
             ForeignItemKind::TyAlias(box TyAlias {
                 defaultness,
@@ -1672,10 +1681,19 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
         }
 
         if let FnKind::Fn(ctxt, _, fun) = fk
-            && let Extern::Explicit(str_lit, _) = fun.sig.header.ext
+            && let Extern::Explicit(str_lit, extern_abi_span) = fun.sig.header.ext
             && let Ok(abi) = ExternAbi::from_str(str_lit.symbol.as_str())
         {
             self.check_extern_fn_signature(abi, ctxt, &fun.ident, &fun.sig);
+
+            if let Some(attr) = attr::find_by_name(attrs, sym::track_caller)
+                && abi != ExternAbi::Rust
+            {
+                self.dcx().emit_err(errors::RequiresRustAbi {
+                    track_caller_span: attr.span,
+                    extern_abi_span,
+                });
+            }
         }
 
         self.check_c_variadic_type(fk, attrs);

compiler/rustc_ast_passes/src/errors.rs

@@ -1140,3 +1140,13 @@ pub(crate) struct ScalableVectorBadArch {
     #[primary_span]
     pub span: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag("`#[track_caller]` can only be used with the Rust ABI", code = E0737)]
+pub(crate) struct RequiresRustAbi {
+    #[primary_span]
+    #[label("using `#[track_caller]` here")]
+    pub track_caller_span: Span,
+    #[label("not using the Rust ABI because of this")]
+    pub extern_abi_span: Span,
+}

compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs

@@ -671,6 +671,7 @@ impl<S: Stage> SingleAttributeParser<S> for SanitizeParser {
                         item.path().span(),
                         &[
                             sym::address,
+                            sym::kernel_address,
                             sym::cfi,
                             sym::kcfi,
                             sym::memory,

compiler/rustc_attr_parsing/src/attributes/stability.rs

@@ -376,7 +376,6 @@ pub(crate) fn parse_unstability<S: Stage>(
     let mut reason = None;
     let mut issue = None;
     let mut issue_num = None;
-    let mut is_soft = false;
     let mut implied_by = None;
     let mut old_name = None;
 
@@ -423,12 +422,6 @@ pub(crate) fn parse_unstability<S: Stage>(
                     },
                 };
             }
-            Some(sym::soft) => {
-                if let Err(span) = args.no_args() {
-                    cx.emit_err(session_diagnostics::SoftNoArgs { span });
-                }
-                is_soft = true;
-            }
             Some(sym::implied_by) => {
                 insert_value_into_option_or_error(cx, &param, &mut implied_by, word.unwrap())?
             }
@@ -438,14 +431,7 @@ pub(crate) fn parse_unstability<S: Stage>(
             _ => {
                 cx.expected_specific_argument(
                     param.span(),
-                    &[
-                        sym::feature,
-                        sym::reason,
-                        sym::issue,
-                        sym::soft,
-                        sym::implied_by,
-                        sym::old_name,
-                    ],
+                    &[sym::feature, sym::reason, sym::issue, sym::implied_by, sym::old_name],
                 );
                 return None;
             }
@@ -468,7 +454,6 @@ pub(crate) fn parse_unstability<S: Stage>(
             let level = StabilityLevel::Unstable {
                 reason: UnstableReason::from_opt_reason(reason),
                 issue: issue_num,
-                is_soft,
                 implied_by,
                 old_name,
             };

compiler/rustc_attr_parsing/src/session_diagnostics.rs

@@ -374,13 +374,6 @@ pub(crate) struct InvalidSince {
     pub span: Span,
 }
 
-#[derive(Diagnostic)]
-#[diag("`soft` should not have any arguments")]
-pub(crate) struct SoftNoArgs {
-    #[primary_span]
-    pub span: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag("unknown version literal format, assuming it refers to a future version")]
 pub(crate) struct UnknownVersionLiteral {

compiler/rustc_codegen_ssa/src/codegen_attrs.rs

@@ -150,7 +150,8 @@ fn process_builtin_attrs(
                     && let Some(fn_sig) = try_fn_sig(tcx, did, *attr_span)
                     && fn_sig.skip_binder().abi() != ExternAbi::Rust
                 {
-                    tcx.dcx().emit_err(errors::RequiresRustAbi { span: *attr_span });
+                    // This error is already reported in `rustc_ast_passes/src/ast_validation.rs`.
+                    tcx.dcx().delayed_bug("`#[track_caller]` requires the Rust ABI");
                 }
                 if is_closure
                     && !tcx.features().closure_track_caller()

compiler/rustc_codegen_ssa/src/errors.rs

@@ -112,13 +112,6 @@ pub(crate) struct NoSavedObjectFile<'a> {
     pub cgu_name: &'a str,
 }
 
-#[derive(Diagnostic)]
-#[diag("`#[track_caller]` requires Rust ABI", code = E0737)]
-pub(crate) struct RequiresRustAbi {
-    #[primary_span]
-    pub span: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag("unable to copy {$source_file} to {$output_path}: {$error}")]
 pub(crate) struct CopyPathBuf {

compiler/rustc_errors/src/lib.rs

@@ -138,6 +138,14 @@ impl Suggestions {
             Suggestions::Disabled => Vec::new(),
         }
     }
+
+    pub fn len(&self) -> usize {
+        match self {
+            Suggestions::Enabled(suggestions) => suggestions.len(),
+            Suggestions::Sealed(suggestions) => suggestions.len(),
+            Suggestions::Disabled => 0,
+        }
+    }
 }
 
 impl Default for Suggestions {

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -277,15 +277,15 @@ impl Default for MacroUseArgs {
 }
 
 #[derive(Debug, Clone, Encodable, Decodable, HashStable_Generic)]
-pub struct StrippedCfgItem<ModId = DefId> {
-    pub parent_module: ModId,
+pub struct StrippedCfgItem<ScopeId = DefId> {
+    pub parent_scope: ScopeId,
     pub ident: Ident,
     pub cfg: (CfgEntry, Span),
 }
 
-impl<ModId> StrippedCfgItem<ModId> {
-    pub fn map_mod_id<New>(self, f: impl FnOnce(ModId) -> New) -> StrippedCfgItem<New> {
-        StrippedCfgItem { parent_module: f(self.parent_module), ident: self.ident, cfg: self.cfg }
+impl<ScopeId> StrippedCfgItem<ScopeId> {
+    pub fn map_scope_id<New>(self, f: impl FnOnce(ScopeId) -> New) -> StrippedCfgItem<New> {
+        StrippedCfgItem { parent_scope: f(self.parent_scope), ident: self.ident, cfg: self.cfg }
     }
 }
 

compiler/rustc_hir/src/stability.rs

@@ -112,7 +112,6 @@ pub enum StabilityLevel {
         reason: UnstableReason,
         /// Relevant `rust-lang/rust` issue.
         issue: Option<NonZero<u32>>,
-        is_soft: bool,
         /// If part of a feature is stabilized and a new feature is added for the remaining parts,
         /// then the `implied_by` attribute is used to indicate which now-stable feature previously
         /// contained an item.