Rollup of 30 pull requests

.github/renovate.json5

@@ -19,8 +19,13 @@
     "src/doc/book",
     "src/doc/reference"
   ],
-  // Require manual approval from the Dependency Dashboard before opening PRs
+  // Require manual approval from the Dependency Dashboard before opening PRs,
+  // except for the update types explicitly configured below.
   "dependencyDashboardApproval": true,
+  // No dashboard approval necessary for security updates
+  "vulnerabilityAlerts": {
+    "dependencyDashboardApproval": false
+  },
   // Renovate shouldn't update a PR if it is in the bors merge queue.
   "stopUpdatingLabel": "S-waiting-on-bors",
   "packageRules": [

.github/workflows/ci.yml

@@ -13,6 +13,7 @@ on:
     branches:
       - automation/bors/auto
       - automation/bors/try
+      - automation/bors/try-perf
       - try-perf
   pull_request:
     branches:
@@ -34,7 +35,7 @@ concurrency:
   # We add an exception for try builds (automation/bors/try branch) and unrolled rollup builds
   # (try-perf), which are all triggered on the same branch, but which should be able to run
   # concurrently.
-  group: ${{ github.workflow }}-${{ ((github.ref == 'refs/heads/try-perf' || github.ref == 'refs/heads/automation/bors/try') && github.sha) || github.ref }}
+  group: ${{ github.workflow }}-${{ ((github.ref == 'refs/heads/try-perf' || github.ref == 'refs/heads/automation/bors/try-perf' || github.ref == 'refs/heads/automation/bors/try') && github.sha) || github.ref }}
   cancel-in-progress: true
 env:
   TOOLSTATE_REPO: "https://github.com/rust-lang-nursery/rust-toolstate"
@@ -79,7 +80,7 @@ jobs:
     # access the environment.
     #
     # We only enable the environment for the rust-lang/rust repository, so that CI works on forks.
-    environment: ${{ ((github.repository == 'rust-lang/rust' && (github.ref == 'refs/heads/try-perf' || github.ref == 'refs/heads/automation/bors/try' || github.ref == 'refs/heads/automation/bors/auto')) && 'bors') || '' }}
+    environment: ${{ ((github.repository == 'rust-lang/rust' && (github.ref == 'refs/heads/try-perf' || github.ref == 'refs/heads/automation/bors/try' || github.ref == 'refs/heads/automation/bors/try-perf' || github.ref == 'refs/heads/automation/bors/auto')) && 'bors') || '' }}
     env:
       CI_JOB_NAME: ${{ matrix.name }}
       CI_JOB_DOC_URL: ${{ matrix.doc_url }}

compiler/rustc_ast_lowering/src/asm.rs

@@ -93,7 +93,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 match asm::InlineAsmClobberAbi::parse(
                     asm_arch,
                     &self.tcx.sess.target,
-                    &self.tcx.sess.unstable_target_features,
+                    &self.tcx.sess.internal_target_features,
                     *abi_name,
                 ) {
                     Ok(abi) => {

compiler/rustc_ast_lowering/src/delegation/generics.rs

@@ -662,10 +662,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
             p.def_id.to_def_id(),
         );
 
-        self.create_resolved_path(res, p.name.ident(), p.span)
+        self.create_resolved_qpath(res, p.name.ident(), p.span)
     }
 
-    pub(super) fn create_resolved_path(
+    pub(super) fn create_resolved_qpath(
         &mut self,
         res: Res,
         ident: Ident,

compiler/rustc_ast_lowering/src/delegation/mod.rs

@@ -439,7 +439,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             };
 
             let ident = Ident::new(kw::SelfUpper, span);
-            let path = self.create_resolved_path(res, ident, span);
+            let path = self.create_resolved_qpath(res, ident, span);
 
             // FIXME(fn_delegation): add default `..` for all other fields.
             let initializer = hir::ExprKind::Struct(
@@ -454,7 +454,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 hir::StructTailExpr::None,
             );
 
-            self.arena.alloc(self.mk_expr(initializer, span))
+            let expr = self.mk_expr(initializer, span);
+
+            let path = self.make_lang_item_qpath(hir::LangItem::FromFn, span, None);
+            let path = self.arena.alloc(self.mk_expr(hir::ExprKind::Path(path), span));
+
+            let call = hir::ExprKind::Call(path, self.arena.alloc_slice(&[expr]));
+
+            self.arena.alloc(self.mk_expr(call, span))
         } else {
             self.arena.alloc(call)
         };

compiler/rustc_ast_lowering/src/delegation/resolution.rs

@@ -5,10 +5,10 @@ use hir::def::DefKind;
 use rustc_ast::{self as ast, Delegation, DelegationSource, NodeId};
 use rustc_data_structures::fx::{FxHashSet, FxIndexSet};
 use rustc_hir as hir;
-use rustc_middle::ty::Ty;
+use rustc_middle::ty::{Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitor};
 use rustc_middle::{span_bug, ty};
 use rustc_span::def_id::{DefId, LocalDefId};
-use rustc_span::{ErrorGuaranteed, Span, kw};
+use rustc_span::{ErrorGuaranteed, Span};
 
 use crate::delegation::generics::GenericsGenerationResults;
 use crate::delegation::resolution::resolver::DelegationResolver;
@@ -31,7 +31,7 @@ pub(super) struct ParamInfo {
     pub splatted: Option<u8>,
 }
 
-#[derive(Default)]
+#[derive(Default, Debug)]
 pub(super) struct SigMapping {
     pub map_return: bool,
     pub arguments_to_map: FxIndexSet<usize>,
@@ -254,17 +254,52 @@ impl<'tcx> DelegationResolver<'_, 'tcx> {
         }
 
         if self.can_perform_self_mapping(delegation, parent)? {
-            // FIXME(fn_delegation): support heuristics for mapping of complex
-            // return types: `Self` -> `Box<Arc<Rc<Self>>>`
-            mapping.map_return = sig.output().is_param(0);
+            /// Finds `Self` generic param only in ADT or references, so we avoid cases like
+            /// `Self::Item` which will return true if `output.contains(...)` will be used.
+            struct SelfFinder;
+
+            impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for SelfFinder {
+                type Result = ControlFlow<()>;
+
+                fn visit_ty(&mut self, t: Ty<'tcx>) -> Self::Result {
+                    match t.kind() {
+                        ty::Adt(_, args) => {
+                            if args
+                                .iter()
+                                .flat_map(|arg| arg.as_type())
+                                .any(|type_arg| type_arg.is_self_param())
+                            {
+                                return ControlFlow::Break(());
+                            }
+
+                            t.super_visit_with(self)
+                        }
+                        ty::Ref(_, ref_t, _) => {
+                            if ref_t.is_self_param() {
+                                return ControlFlow::Break(());
+                            }
+
+                            t.super_visit_with(self)
+                        }
+                        _ => ControlFlow::Continue(()),
+                    }
+                }
+            }
+
+            impl SelfFinder {
+                fn contains_self(t: Ty<'_>) -> bool {
+                    t.is_self_param() || t.visit_with(&mut SelfFinder).is_break()
+                }
+            }
+
+            mapping.map_return = SelfFinder::contains_self(sig.output());
 
-            let self_param = Ty::new_param(self.tcx(), 0, kw::SelfUpper);
             let arguments_to_map = sig
                 .inputs()
                 .iter()
                 .enumerate()
                 .skip(1) // Already checked above.
-                .filter_map(|(idx, param)| param.contains(self_param).then_some(idx));
+                .filter_map(|(idx, &param)| SelfFinder::contains_self(param).then_some(idx));
 
             mapping.arguments_to_map.extend(arguments_to_map);
         }

compiler/rustc_attr_parsing/src/attributes/diagnostic/mod.rs

@@ -1,16 +1,20 @@
 use std::ops::Range;
 
+use rustc_ast::PathSegment;
+use rustc_errors::{Diagnostic, MultiSpan};
 use rustc_hir::attrs::diagnostic::{
     Directive, Filter, FilterFormatString, Flag, FormatArg, FormatString, LitOrArg, Name,
     NameValue, Piece, Predicate,
 };
+use rustc_lint_defs::LintId;
 use rustc_parse_format::{
     Argument, FormatSpec, ParseError, ParseMode, Parser, Piece as RpfPiece, Position,
 };
 use rustc_session::lint::builtin::{
     MALFORMED_DIAGNOSTIC_ATTRIBUTES, MALFORMED_DIAGNOSTIC_FILTERS,
-    MALFORMED_DIAGNOSTIC_FORMAT_LITERALS,
+    MALFORMED_DIAGNOSTIC_FORMAT_LITERALS, UNKNOWN_DIAGNOSTIC_ATTRIBUTES,
 };
+use rustc_span::edit_distance::find_best_match_for_name;
 use rustc_span::{Ident, InnerSpan, Span, Symbol, kw, sym};
 use thin_vec::{ThinVec, thin_vec};
 
@@ -20,6 +24,7 @@ use crate::diagnostics::{
     MissingOptionsForDiagnosticAttribute, NonMetaItemDiagnosticAttribute, WrappedParserError,
 };
 use crate::parser::{ArgParser, MetaItemListParser, MetaItemOrLitParser, MetaItemParser};
+use crate::{EmitAttribute, diagnostics};
 
 pub(crate) mod do_not_recommend;
 pub(crate) mod on_const;
@@ -30,6 +35,67 @@ pub(crate) mod on_unknown;
 pub(crate) mod on_unmatched_args;
 pub(crate) mod opaque;
 
+impl<'sess> crate::AttributeParser<'sess> {
+    pub(crate) fn unknown_diagnostic_attr(
+        &self,
+        segment: &PathSegment,
+        mut emit_lint: impl FnMut(LintId, MultiSpan, EmitAttribute),
+    ) {
+        const DIAGNOSTIC_ATTRIBUTES: [(
+            Symbol,         /* name */
+            Option<Symbol>, /* feature gate */
+        ); 8] = [
+            (sym::on_unimplemented, None),
+            (sym::do_not_recommend, None),
+            (sym::on_move, Some(sym::diagnostic_on_move)),
+            (sym::on_const, Some(sym::diagnostic_on_const)),
+            (sym::on_unknown, Some(sym::diagnostic_on_unknown)),
+            (sym::on_unmatched_args, Some(sym::diagnostic_on_unmatched_args)),
+            (sym::on_type_error, Some(sym::diagnostic_on_type_error)),
+            (sym::opaque, Some(sym::diagnostic_opaque)),
+        ];
+        // No need to emit a lint if features aren't available.
+        let Some(features) = self.features else { return };
+        let span = segment.span();
+        let candidates = DIAGNOSTIC_ATTRIBUTES
+            .iter()
+            .filter_map(|(attr, feature)| {
+                feature.is_none_or(|f| features.enabled(f)).then_some(*attr)
+            })
+            .collect::<Vec<_>>();
+
+        let typo = find_best_match_for_name(&candidates, segment.ident.name, None)
+            .map(|typo_name| diagnostics::UnknownDiagnosticAttributeTypo { span, typo_name });
+        emit_lint(
+            LintId::of(UNKNOWN_DIAGNOSTIC_ATTRIBUTES),
+            span.into(),
+            EmitAttribute(Box::new(move |dcx, level, _| {
+                diagnostics::UnknownDiagnosticAttribute { typo }.into_diag(dcx, level)
+            })),
+        )
+    }
+}
+
+#[rustc_macro_transparency = "transparent"]
+macro gate_diagnostic_attr($feature:ident) {{
+    if let Some(features) = cx.features_option()
+        && !features.$feature()
+    {
+        args.ignore_args();
+        let nightly_build = cx.sess.is_nightly_build();
+        let span = cx.attr_span;
+        cx.emit_lint(
+            rustc_lint_defs::builtin::UNKNOWN_DIAGNOSTIC_ATTRIBUTES,
+            $crate::diagnostics::UnstableDiagnosticAttribute {
+                feature: sym::$feature,
+                nightly_build,
+            },
+            span,
+        );
+        return;
+    }
+}}
+
 #[derive(Copy, Clone)]
 pub(crate) enum Mode {
     /// `#[rustc_on_unimplemented]`

compiler/rustc_attr_parsing/src/attributes/diagnostic/on_const.rs

@@ -13,13 +13,9 @@ impl AttributeParser for OnConstParser {
     const ATTRIBUTES: AcceptMapping<Self> = &[(
         &[sym::diagnostic, sym::on_const],
         template!(List: &[r#"/*opt*/ message = "...", /*opt*/ label = "...", /*opt*/ note = "...""#]),
-        AttributeStability::Stable, // Unstable, stability checked manually in the parser
+        AttributeStability::Stable, // Unstable, stability checked manually below
         |this, cx, args| {
-            if !cx.features().diagnostic_on_const() {
-                // `UnknownDiagnosticAttribute` is emitted in rustc_resolve/macros.rs
-                args.ignore_args();
-                return;
-            }
+            gate_diagnostic_attr!(diagnostic_on_const);
 
             let path_span = cx.attr_path.span;
             this.path_span = Some(path_span);

compiler/rustc_attr_parsing/src/attributes/diagnostic/on_move.rs

@@ -4,8 +4,6 @@ use rustc_span::sym;
 
 use crate::attributes::diagnostic::*;
 use crate::attributes::prelude::*;
-use crate::context::AcceptContext;
-use crate::parser::ArgParser;
 use crate::target_checking::AllowedTargets;
 use crate::template;
 
@@ -15,31 +13,23 @@ pub(crate) struct OnMoveParser {
     directive: Option<(Span, Directive)>,
 }
 
-impl OnMoveParser {
-    fn parse<'sess>(&mut self, cx: &mut AcceptContext<'_, 'sess>, args: &ArgParser, mode: Mode) {
-        if !cx.features().diagnostic_on_move() {
-            // `UnknownDiagnosticAttribute` is emitted in rustc_resolve/macros.rs
-            args.ignore_args();
-            return;
-        }
-
-        let span = cx.attr_span;
-        self.span = Some(span);
-
-        let Some(items) = parse_list(cx, args, mode) else { return };
-
-        if let Some(directive) = parse_directive_items(cx, mode, items.mixed(), true) {
-            merge_directives(cx, &mut self.directive, (span, directive));
-        }
-    }
-}
 impl AttributeParser for OnMoveParser {
     const ATTRIBUTES: AcceptMapping<Self> = &[(
         &[sym::diagnostic, sym::on_move],
         template!(List: &[r#"/*opt*/ message = "...", /*opt*/ label = "...", /*opt*/ note = "...""#]),
-        AttributeStability::Stable, // Unstable, stability checked manually in the parser
+        AttributeStability::Stable, // Unstable, stability checked manually below
         |this, cx, args| {
-            this.parse(cx, args, Mode::DiagnosticOnMove);
+            gate_diagnostic_attr!(diagnostic_on_move);
+
+            let span = cx.attr_span;
+            this.span = Some(span);
+            let mode = Mode::DiagnosticOnMove;
+
+            let Some(items) = parse_list(cx, args, mode) else { return };
+
+            if let Some(directive) = parse_directive_items(cx, mode, items.mixed(), true) {
+                merge_directives(cx, &mut this.directive, (span, directive));
+            }
         },
     )];
 

compiler/rustc_attr_parsing/src/attributes/diagnostic/on_type_error.rs

@@ -4,8 +4,6 @@ use rustc_span::sym;
 use crate::attributes::AttributeStability;
 use crate::attributes::diagnostic::*;
 use crate::attributes::prelude::*;
-use crate::context::AcceptContext;
-use crate::parser::ArgParser;
 use crate::target_checking::AllowedTargets;
 use crate::template;
 
@@ -15,32 +13,22 @@ pub(crate) struct OnTypeErrorParser {
     directive: Option<(Span, Directive)>,
 }
 
-impl OnTypeErrorParser {
-    fn parse<'sess>(&mut self, cx: &mut AcceptContext<'_, 'sess>, args: &ArgParser, mode: Mode) {
-        if !cx.features().diagnostic_on_type_error() {
-            // `UnknownDiagnosticAttribute` is emitted in rustc_resolve/macros.rs
-            args.ignore_args();
-            return;
-        }
-
-        let span = cx.attr_span;
-        self.span = Some(span);
-
-        let Some(items) = parse_list(cx, args, mode) else { return };
-
-        if let Some(directive) = parse_directive_items(cx, mode, items.mixed(), true) {
-            merge_directives(cx, &mut self.directive, (span, directive));
-        }
-    }
-}
-
 impl AttributeParser for OnTypeErrorParser {
     const ATTRIBUTES: AcceptMapping<Self> = &[(
         &[sym::diagnostic, sym::on_type_error],
         template!(List: &[r#"note = "...""#]),
-        AttributeStability::Stable,
+        AttributeStability::Stable, // Unstable, stability checked manually below
         |this, cx, args| {
-            this.parse(cx, args, Mode::DiagnosticOnTypeError);
+            gate_diagnostic_attr!(diagnostic_on_type_error);
+
+            let span = cx.attr_span;
+            this.span = Some(span);
+            let mode = Mode::DiagnosticOnTypeError;
+            let Some(items) = parse_list(cx, args, mode) else { return };
+
+            if let Some(directive) = parse_directive_items(cx, mode, items.mixed(), true) {
+                merge_directives(cx, &mut this.directive, (span, directive));
+            }
         },
     )];