Auto merge of #158027 - JonathanBrouwer:rollup-nUxhyJT, r=<try>

Rollup of 8 pull requests


try-job: dist-various-1
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
try-job: i686-msvc-2

Author: bors

compiler/rustc_attr_parsing/src/attributes/doc.rs

@@ -22,7 +22,7 @@ use crate::diagnostics::{
 use crate::parser::{ArgParser, MetaItemOrLitParser, MetaItemParser, OwnedPathParser};
 use crate::session_diagnostics::{
     DocAliasBadChar, DocAliasEmpty, DocAliasMalformed, DocAliasStartEnd, DocAttrNotCrateLevel,
-    DocAttributeNotAttribute, DocKeywordNotKeyword,
+    DocAttributeNotAttribute, DocKeywordNotKeyword, UnusedDuplicate,
 };
 
 fn check_keyword(cx: &mut AcceptContext<'_, '_>, keyword: Symbol, span: Span) -> bool {
@@ -159,11 +159,7 @@ impl DocParser {
                     let unused_span = path.span();
                     cx.emit_lint(
                         rustc_session::lint::builtin::INVALID_DOC_ATTRIBUTES,
-                        rustc_errors::lints::UnusedDuplicate {
-                            this: unused_span,
-                            other: used_span,
-                            warning: true,
-                        },
+                        UnusedDuplicate { this: unused_span, other: used_span, warning: true },
                         unused_span,
                     );
                     return;

compiler/rustc_attr_parsing/src/context.rs

@@ -71,7 +71,7 @@ use crate::parser::{
 };
 use crate::session_diagnostics::{
     AttributeParseError, AttributeParseErrorReason, AttributeParseErrorSuggestions,
-    ParsedDescription,
+    ParsedDescription, UnusedDuplicate,
 };
 use crate::target_checking::AllowedTargets;
 use crate::{AttrSuggestionStyle, AttributeParser, AttributeTemplate, EmitAttribute};
@@ -436,11 +436,7 @@ impl<'f, 'sess: 'f> SharedContext<'f, 'sess> {
     pub(crate) fn warn_unused_duplicate(&mut self, used_span: Span, unused_span: Span) {
         self.emit_lint(
             rustc_session::lint::builtin::UNUSED_ATTRIBUTES,
-            rustc_errors::lints::UnusedDuplicate {
-                this: unused_span,
-                other: used_span,
-                warning: false,
-            },
+            UnusedDuplicate { this: unused_span, other: used_span, warning: false },
             unused_span,
         )
     }
@@ -452,11 +448,7 @@ impl<'f, 'sess: 'f> SharedContext<'f, 'sess> {
     ) {
         self.emit_lint(
             rustc_session::lint::builtin::UNUSED_ATTRIBUTES,
-            rustc_errors::lints::UnusedDuplicate {
-                this: unused_span,
-                other: used_span,
-                warning: true,
-            },
+            UnusedDuplicate { this: unused_span, other: used_span, warning: true },
             unused_span,
         )
     }

compiler/rustc_attr_parsing/src/session_diagnostics.rs

@@ -1045,3 +1045,16 @@ pub(crate) struct AdditionalCommaSuggestion {
     #[primary_span]
     pub span: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag("unused attribute")]
+pub(crate) struct UnusedDuplicate {
+    #[suggestion("remove this attribute", code = "", applicability = "machine-applicable")]
+    pub this: Span,
+    #[note("attribute also specified here")]
+    pub other: Span,
+    #[warning(
+        "this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!"
+    )]
+    pub warning: bool,
+}

compiler/rustc_errors/src/lib.rs

@@ -79,7 +79,6 @@ mod diagnostic_impls;
 pub mod emitter;
 pub mod formatting;
 pub mod json;
-pub mod lints;
 mod lock;
 pub mod markdown;
 pub mod timings;

compiler/rustc_errors/src/lints.rs

@@ -606,37 +606,61 @@ impl_lint_pass!(MissingDebugImplementations => [MISSING_DEBUG_IMPLEMENTATIONS]);
 
 impl<'tcx> LateLintPass<'tcx> for MissingDebugImplementations {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &hir::Item<'_>) {
-        if !cx.effective_visibilities.is_reachable(item.owner_id.def_id) {
+        let def_id = item.owner_id.def_id;
+        if !cx.effective_visibilities.is_reachable(def_id) {
             return;
         }
 
-        match item.kind {
-            hir::ItemKind::Struct(..) | hir::ItemKind::Union(..) | hir::ItemKind::Enum(..) => {}
+        let is_generic = match item.kind {
+            hir::ItemKind::Struct(_, generics, _)
+            | hir::ItemKind::Union(_, generics, _)
+            | hir::ItemKind::Enum(_, generics, _) => !generics.params.is_empty(),
             _ => return,
-        }
+        };
+
+        let tcx = cx.tcx;
 
         // Avoid listing trait impls if the trait is allowed.
-        if cx.tcx.lint_level_spec_at_node(MISSING_DEBUG_IMPLEMENTATIONS, item.hir_id()).is_allow() {
+        if tcx.lint_level_spec_at_node(MISSING_DEBUG_IMPLEMENTATIONS, item.hir_id()).is_allow() {
             return;
         }
 
-        let Some(debug) = cx.tcx.get_diagnostic_item(sym::Debug) else { return };
+        let Some(debug) = tcx.get_diagnostic_item(sym::Debug) else { return };
 
-        let has_impl = cx
-            .tcx
-            .non_blanket_impls_for_ty(
-                debug,
-                cx.tcx.type_of(item.owner_id).instantiate_identity().skip_norm_wip(),
-            )
+        let ty = tcx.type_of(item.owner_id);
+        if tcx
+            .non_blanket_impls_for_ty(debug, ty.instantiate_identity().skip_norm_wip())
             .next()
-            .is_some();
-        if !has_impl {
-            cx.emit_span_lint(
-                MISSING_DEBUG_IMPLEMENTATIONS,
-                item.span,
-                BuiltinMissingDebugImpl { tcx: cx.tcx, def_id: debug },
-            );
+            .is_some()
+        {
+            return;
         }
+
+        let infcx = tcx.infer_ctxt().build(cx.typing_mode());
+        if is_generic {
+            let args = infcx.fresh_args_for_item(item.span, def_id.to_def_id());
+            if infcx
+                .type_implements_trait_shallow(
+                    debug,
+                    ty.instantiate(tcx, args).skip_norm_wip(),
+                    cx.param_env,
+                )
+                .is_some()
+            {
+                return;
+            }
+        } else if infcx
+            .type_implements_trait(debug, [ty.instantiate_identity().skip_norm_wip()], cx.param_env)
+            .must_apply_modulo_regions()
+        {
+            return;
+        }
+
+        cx.emit_span_lint(
+            MISSING_DEBUG_IMPLEMENTATIONS,
+            item.span,
+            BuiltinMissingDebugImpl { tcx: cx.tcx, def_id: debug },
+        );
     }
 }
 

compiler/rustc_lint/src/builtin.rs

@@ -1,14 +1,14 @@
 // tidy-alphabetical-start
 #![allow(internal_features)]
 #![cfg_attr(bootstrap, feature(result_option_map_or_default))]
+#![cfg_attr(bootstrap, feature(strip_circumfix))]
 #![feature(error_iter)]
 #![feature(file_buffered)]
 #![feature(gen_blocks)]
 #![feature(macro_metavar_expr)]
 #![feature(min_specialization)]
 #![feature(never_type)]
 #![feature(proc_macro_internals)]
-#![feature(strip_circumfix)]
 #![feature(trusted_len)]
 // tidy-alphabetical-end
 

compiler/rustc_metadata/src/lib.rs

@@ -310,7 +310,9 @@ impl<'tcx> InstanceKind<'tcx> {
 
     pub fn requires_caller_location(&self, tcx: TyCtxt<'_>) -> bool {
         match *self {
-            InstanceKind::Item(def_id) | InstanceKind::Virtual(def_id, _) => {
+            InstanceKind::Item(def_id)
+            | InstanceKind::Virtual(def_id, _)
+            | InstanceKind::VTableShim(def_id) => {
                 tcx.body_codegen_attrs(def_id).flags.contains(CodegenFnAttrFlags::TRACK_CALLER)
             }
             InstanceKind::ClosureOnceShim { call_once: _, closure: _, track_caller } => {

compiler/rustc_middle/src/ty/instance.rs

@@ -689,7 +689,7 @@ pub(crate) struct MissingInInForLoop {
     #[primary_span]
     pub span: Span,
     #[subdiagnostic]
-    pub sub: MissingInInForLoopSub,
+    pub sub: Option<MissingInInForLoopSub>,
 }
 
 #[derive(Subdiagnostic)]

compiler/rustc_parse/src/errors.rs

@@ -3086,18 +3086,41 @@ impl<'a> Parser<'a> {
     }
 
     fn error_missing_in_for_loop(&mut self) {
-        let (span, sub): (_, fn(_) -> _) = if self.token.is_ident_named(sym::of) {
+        let (span, sub) = if self.token.is_ident_named(sym::of) {
             // Possibly using JS syntax (#75311).
             let span = self.token.span;
             self.bump();
-            (span, errors::MissingInInForLoopSub::InNotOf)
+            (span, Some(errors::MissingInInForLoopSub::InNotOf(span)))
         } else if self.eat(exp!(Eq)) {
-            (self.prev_token.span, errors::MissingInInForLoopSub::InNotEq)
+            let span = self.prev_token.span;
+            (span, Some(errors::MissingInInForLoopSub::InNotEq(span)))
         } else {
-            (self.prev_token.span.between(self.token.span), errors::MissingInInForLoopSub::AddIn)
+            let span = self.prev_token.span.between(self.token.span);
+            let sub = (!self.for_loop_head_has_in())
+                .then_some(errors::MissingInInForLoopSub::AddIn(span));
+            (span, sub)
         };
 
-        self.dcx().emit_err(errors::MissingInInForLoop { span, sub: sub(span) });
+        self.dcx().emit_err(errors::MissingInInForLoop { span, sub });
+    }
+
+    /// Whether the `for` loop header already contains an `in` before its body.
+    /// If it does, the binding is malformed (e.g. `for i i in 0..10`) rather
+    /// than missing `in`, so suggesting another `in` would just be invalid too.
+    fn for_loop_head_has_in(&self) -> bool {
+        let mut dist = 0;
+        loop {
+            let (is_in, is_end) = self.look_ahead(dist, |t| {
+                (t.is_keyword(kw::In), matches!(t.kind, token::OpenBrace | token::Eof))
+            });
+            if is_in {
+                return true;
+            }
+            if is_end {
+                return false;
+            }
+            dist += 1;
+        }
     }
 
     /// Parses a `while` or `while let` expression (`while` token already eaten).