Auto merge of #160284 - JonathanBrouwer:rollup-Jwar7OO, r=JonathanBrouwer

Rollup of 22 pull requests

Successful merges:

 - #160100 (Add "system" option to `override-allocator` directive)
 - #160220 (Refactor: shrink region ext traits)
 - #159675 (rustc: Support `--jobs` options for limiting parallelism in various parts of the compiler)
 - #159999 (Fix invalidation of stdlib in bootstrap when using non-LLVM codegen backends)
 - #160233 (Bubble bad path error while parsing field to avoid unecessary second error)
 - #160272 (rustc_metadata: Move native library search code to `rustc_codegen_ssa`)
 - #154202 (rustfmt: Format `cfg_select!`)
 - #159520 (Suggest `Vec<T>` instead of `[T]`)
 - #159710 (Add rustdoc/cargo PGO profiles to reproducible artifacts)
 - #160034 (Move "macro only" check for `#[allow_internal_unsafe/unstable]` to attribute parser)
 - #160066 (rustc_middle: lint attribute cleanups)
 - #160085 (Remove various superfluous lint attributes)
 - #160113 (Coalesce `rustc_on_unimplemented` attributes and lint malformed filters)
 - #160119 (fix query cycle in `coroutine_hidden_types` for the next solver)
 - #160147 (tests: Remove `-Zthreads` options from tests in `ui/parallel-rustc`)
 - #160157 (Remove outdated comments from `va_list.rs`)
 - #160159 (More accurately check for interior mutability in `invalid_reference_casting` lint)
 - #160208 (rustdoc: Fix crash when trying to list attributes on an opaque type)
 - #160244 (Rename splat to rustc_splat in error messages)
 - #160246 (dont fire `unused_mut` on `&pin mut self`)
 - #160247 (Configure backport nominations for rustfmt)
 - #160274 (renovate: update lock files weekly)

Author: bors

.github/renovate.json5

@@ -5,9 +5,8 @@
     "github>rust-lang/renovate:actions",
     // Open a PR to migrate the config when Renovate deprecates syntax
     ":configMigration",
-    // Refresh lock files on the first day of each month
-    // (still gated by dashboard approval for now)
-    ":maintainLockFilesMonthly",
+    // Refresh lock files weekly
+    ":maintainLockFilesWeekly",
   ],
   // Cargo manifests in this repository use unstable features.
   "env": {
@@ -30,6 +29,11 @@
       "matchManagers": ["github-actions"],
       "dependencyDashboardApproval": false
     },
+    {
+      // No dashboard approval necessary for lock file maintenance
+      "matchUpdateTypes": ["lockFileMaintenance"],
+      "dependencyDashboardApproval": false
+    },
     {
       // Update all Cargo.lock files except library/Cargo.lock in one PR.
       "matchManagers": ["cargo"],

Cargo.lock

@@ -4355,6 +4355,7 @@ version = "0.0.0"
 dependencies = [
  "fluent-bundle",
  "fluent-syntax",
+ "indexmap",
  "proc-macro2",
  "quote",
  "syn",

INSTALL.md

@@ -96,7 +96,7 @@ See [the rustc-dev-guide for more info][sysllvm].
       --set llvm.libzstd=true \
       --set llvm.ninja=false \
       --set rust.debug-assertions=false \
-      --set rust.override-allocator=jemalloc \
+      --set build.allocator=jemalloc \
       --set rust.bootstrap-override-lld=true \
       --set rust.lto=thin \
       --set rust.codegen-units=1

bootstrap.example.toml

@@ -544,6 +544,12 @@
 # For example, exclude = ["tests/ui", "src/tools/tidy"].
 #build.exclude = []
 
+# Link the compiler and LLVM against the specified allocator instead of the default libc allocator.
+# This option is only tested on Linux and OSX. It can also be configured per-target in the
+# [target.<tuple>] section.
+# Possible options: "system" (default), "jemalloc"
+#build.allocator = "jemalloc"
+
 # =============================================================================
 # General install configuration options
 # =============================================================================
@@ -859,15 +865,9 @@
 # Useful for reproducible builds. Generally only set for releases
 #rust.remap-debuginfo = false
 
-# Link the compiler and LLVM against the specified allocator instead of the default libc allocator.
-# This option is only tested on Linux and OSX. It can also be configured per-target in the
-# [target.<tuple>] section.
-# Possible options: "jemalloc"
-#rust.override-allocator = "jemalloc"
-
-# Deprecated alias for `rust.override-allocator`. Setting this to `true` is
-# equivalent to `rust.override-allocator = "jemalloc"`. If both are set, they
-# must agree.
+# Deprecated alias for `build.allocator`. Setting this to `true` is
+# equivalent to `build.allocator = "jemalloc"`. Both cannot be set in the same section
+# (`rust` or `target.[target]`)
 #rust.jemalloc = false
 
 # Run tests in various test suites with the "nll compare mode" in addition to
@@ -1177,10 +1177,10 @@
 #optimized-compiler-builtins = build.optimized-compiler-builtins (bool or path)
 
 # Link the compiler and LLVM against the specified allocator instead of the default libc allocator.
-# This overrides the global `rust.override-allocator` option. See that option for more info.
-#override-allocator = rust.override-allocator (string)
+# This overrides the global `build.allocator` option. See that option for more info.
+#allocator = build.allocator (string)
 
-# Deprecated alias for `override-allocator`. See `rust.jemalloc` for more info.
+# Deprecated alias for `allocator`. See `rust.jemalloc` for more info.
 #jemalloc = rust.jemalloc (bool)
 
 # The linker configuration that will *override* the default linker used for Linux

compiler/rustc_ast/src/ast.rs

@@ -3008,7 +3008,7 @@ impl Param {
                 }),
             ),
             SelfKind::Pinned(lt, mutbl) => (
-                mutbl,
+                Mutability::Not,
                 Box::new(Ty {
                     id: DUMMY_NODE_ID,
                     kind: TyKind::PinnedRef(lt, MutTy { ty: infer_ty, mutbl }),

compiler/rustc_attr_parsing/src/attributes/allow_unstable.rs

@@ -2,6 +2,7 @@ use std::iter;
 
 use rustc_feature::AttributeStability;
 
+use super::macro_attrs::check_macro_only;
 use super::prelude::*;
 use crate::session_diagnostics;
 
@@ -28,6 +29,10 @@ impl CombineAttributeParser for AllowInternalUnstableParser {
             .into_iter()
             .zip(iter::repeat(cx.attr_span))
     }
+
+    fn finalize_check(cx: &FinalizeCheckContext<'_, '_>, attr_span: Span) {
+        check_macro_only(cx, attr_span);
+    }
 }
 
 pub(crate) struct UnstableFeatureBoundParser;

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

@@ -8,16 +8,16 @@ use rustc_parse_format::{
     Argument, FormatSpec, ParseError, ParseMode, Parser, Piece as RpfPiece, Position,
 };
 use rustc_session::lint::builtin::{
-    MALFORMED_DIAGNOSTIC_ATTRIBUTES, MALFORMED_DIAGNOSTIC_FORMAT_LITERALS,
+    MALFORMED_DIAGNOSTIC_ATTRIBUTES, MALFORMED_DIAGNOSTIC_FILTERS,
+    MALFORMED_DIAGNOSTIC_FORMAT_LITERALS,
 };
 use rustc_span::{Ident, InnerSpan, Span, Symbol, kw, sym};
 use thin_vec::{ThinVec, thin_vec};
 
 use crate::context::AcceptContext;
 use crate::diagnostics::{
-    DupesNotAllowed, FormatWarning, IgnoredDiagnosticOption, InvalidOnClause,
-    MalFormedDiagnosticAttributeLint, MissingOptionsForDiagnosticAttribute,
-    NonMetaItemDiagnosticAttribute, WrappedParserError,
+    FormatWarning, IgnoredDiagnosticOption, InvalidOnClause, MalFormedDiagnosticAttributeLint,
+    MissingOptionsForDiagnosticAttribute, NonMetaItemDiagnosticAttribute, WrappedParserError,
 };
 use crate::parser::{ArgParser, MetaItemListParser, MetaItemOrLitParser, MetaItemParser};
 
@@ -129,13 +129,14 @@ fn merge_directives(
     later: (Span, Directive),
 ) {
     if let Some((_, first)) = first {
-        if first.is_rustc_attr || later.1.is_rustc_attr {
-            cx.emit_err(DupesNotAllowed);
-        }
-
-        merge(cx, &mut first.message, later.1.message, sym::message);
-        merge(cx, &mut first.label, later.1.label, sym::label);
-        first.notes.extend(later.1.notes);
+        let Directive { is_rustc_attr, filters, message, label, notes, parent_label } = later.1;
+
+        first.is_rustc_attr |= is_rustc_attr;
+        first.filters.extend(filters);
+        merge(cx, &mut first.message, message, sym::message);
+        merge(cx, &mut first.label, label, sym::label);
+        first.notes.extend(notes);
+        merge(cx, &mut first.parent_label, parent_label, sym::parent_label);
     } else {
         *first = Some(later);
     }
@@ -215,7 +216,7 @@ fn parse_directive_items<'p>(
     let mut message: Option<(Span, _)> = None;
     let mut label: Option<(Span, _)> = None;
     let mut notes = ThinVec::new();
-    let mut parent_label = None;
+    let mut parent_label: Option<(Span, FormatString)> = None;
     let mut filters = ThinVec::new();
 
     for item in items {
@@ -346,10 +347,11 @@ fn parse_directive_items<'p>(
             }
             (Mode::RustcOnUnimplemented, sym::parent_label) => {
                 let value = or_malformed!(value?);
-                if parent_label.is_none() {
-                    parent_label = Some(parse_format(value));
+                if let Some(parent_label) = &parent_label {
+                    duplicate!(name, parent_label.0)
                 } else {
-                    duplicate!(name, span)
+                    let format = parse_format(value);
+                    parent_label = Some((format.span, format));
                 }
             }
             (Mode::RustcOnUnimplemented, sym::on) => {
@@ -359,7 +361,11 @@ fn parse_directive_items<'p>(
                     let filter = if let Some(c) = iter.next() {
                         c
                     } else {
-                        cx.emit_err(InvalidOnClause::Empty { span });
+                        cx.emit_lint(
+                            MALFORMED_DIAGNOSTIC_FILTERS,
+                            InvalidOnClause::Empty { span },
+                            span,
+                        );
                         continue;
                     };
 
@@ -378,7 +384,7 @@ fn parse_directive_items<'p>(
                             filters.push((filter, directive));
                         }
                         Err(e) => {
-                            cx.emit_err(e);
+                            cx.emit_lint(MALFORMED_DIAGNOSTIC_FILTERS, e, span);
                         }
                     }
                 } else {

compiler/rustc_attr_parsing/src/attributes/macro_attrs.rs

@@ -1,8 +1,10 @@
 use rustc_feature::AttributeStability;
 use rustc_hir::attrs::{CollapseMacroDebuginfo, MacroUseArgs};
+use rustc_hir::find_attr;
 use rustc_session::lint::builtin::INVALID_MACRO_EXPORT_ARGUMENTS;
 
 use super::prelude::*;
+use crate::session_diagnostics::MacroOnlyAttribute;
 
 pub(crate) struct MacroEscapeParser;
 impl NoArgsAttributeParser for MacroEscapeParser {
@@ -113,6 +115,17 @@ impl AttributeParser for MacroUseParser {
     }
 }
 
+/// `#[allow_internal_unsafe]` and `#[allow_internal_unstable]` may only be applied to macros.
+/// Applying them to a function is only allowed if that function is a procedural macro, i.e. it
+/// also carries `#[proc_macro]`, `#[proc_macro_attribute]`, or `#[proc_macro_derive]`.
+pub(crate) fn check_macro_only(cx: &FinalizeCheckContext<'_, '_>, attr_span: Span) {
+    if cx.target == Target::Fn
+        && !find_attr!(cx.parsed_attrs, ProcMacro | ProcMacroAttribute | ProcMacroDerive { .. })
+    {
+        cx.emit_err(MacroOnlyAttribute { attr_span, span: cx.target_span });
+    }
+}
+
 pub(crate) struct AllowInternalUnsafeParser;
 
 impl NoArgsAttributeParser for AllowInternalUnsafeParser {
@@ -126,6 +139,10 @@ impl NoArgsAttributeParser for AllowInternalUnsafeParser {
     ]);
     const STABILITY: AttributeStability = unstable!(allow_internal_unsafe);
     const CREATE: fn(Span) -> AttributeKind = |span| AttributeKind::AllowInternalUnsafe(span);
+
+    fn finalize_check(cx: &FinalizeCheckContext<'_, '_>, attr_span: Span) {
+        check_macro_only(cx, attr_span);
+    }
 }
 
 pub(crate) struct MacroExportParser;

compiler/rustc_attr_parsing/src/diagnostics.rs

@@ -1,4 +1,4 @@
-use rustc_errors::{Applicability, DiagArgValue, E0232, E0264, MultiSpan};
+use rustc_errors::{Applicability, DiagArgValue, E0264, MultiSpan};
 use rustc_hir::AttrPath;
 use rustc_macros::{Diagnostic, Subdiagnostic};
 use rustc_span::{Ident, Span, Symbol};
@@ -764,39 +764,39 @@ pub(crate) mod unexpected_cfg_value {
 
 #[derive(Diagnostic)]
 pub(crate) enum InvalidOnClause {
-    #[diag("empty `on`-clause in `#[rustc_on_unimplemented]`", code = E0232)]
+    #[diag("empty `on`-clause in `#[rustc_on_unimplemented]`")]
     Empty {
         #[primary_span]
         #[label("empty `on`-clause here")]
         span: Span,
     },
-    #[diag("expected a single predicate in `not(..)`", code = E0232)]
+    #[diag("expected a single predicate in `not(..)`")]
     ExpectedOnePredInNot {
         #[primary_span]
         #[label("unexpected quantity of predicates here")]
         span: Span,
     },
-    #[diag("literals inside `on`-clauses are not supported", code = E0232)]
+    #[diag("literals inside `on`-clauses are not supported")]
     UnsupportedLiteral {
         #[primary_span]
         #[label("unexpected literal here")]
         span: Span,
     },
-    #[diag("expected an identifier inside this `on`-clause", code = E0232)]
+    #[diag("expected an identifier inside this `on`-clause")]
     ExpectedIdentifier {
         #[primary_span]
         #[label("expected an identifier here, not `{$path}`")]
         span: Span,
         path: AttrPath,
     },
-    #[diag("this predicate is invalid", code = E0232)]
+    #[diag("this predicate is invalid")]
     InvalidPredicate {
         #[primary_span]
         #[label("expected one of `any`, `all` or `not` here, not `{$invalid_pred}`")]
         span: Span,
         invalid_pred: Symbol,
     },
-    #[diag("invalid flag in `on`-clause", code = E0232)]
+    #[diag("invalid flag in `on`-clause")]
     InvalidFlag {
         #[primary_span]
         #[label(
@@ -807,12 +807,6 @@ pub(crate) enum InvalidOnClause {
     },
 }
 
-#[derive(Diagnostic)]
-#[diag(
-    "using multiple `rustc_on_unimplemented` (or mixing it with `diagnostic::on_unimplemented`) is not supported"
-)]
-pub(crate) struct DupesNotAllowed;
-
 #[derive(Diagnostic)]
 #[diag("usage of the unsafe `{$attr_path}` attribute")]
 #[note("{$note}")]

compiler/rustc_attr_parsing/src/session_diagnostics.rs

@@ -29,6 +29,15 @@ pub(crate) struct RustcPubTransparent {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag("attribute should be applied to a macro")]
+pub(crate) struct MacroOnlyAttribute {
+    #[primary_span]
+    pub attr_span: Span,
+    #[label("not a macro")]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag("{$attr_str} attribute cannot have empty value")]
 pub(crate) struct DocAliasEmpty<'a> {