Merge ref '235a4c083eb2' from rust-lang/rust

Pull recent changes from https://github.com/rust-lang/rust via Josh.

Upstream ref: 235a4c0
Filtered ref: 548dcbbeab7592100a0ba9f2338ddc8ad1003824
Upstream diff: 36e4f5d...235a4c0

This merge was created using https://github.com/rust-lang/josh-sync.

Author: The Miri Cronjob Bot

.github/workflows/ci.yml

@@ -246,6 +246,8 @@ jobs:
         run: src/ci/scripts/create-doc-artifacts.sh
 
       - name: print disk usage
+        # We also want to know the disk usage when the job fails.
+        if: always()
         run: |
           echo "disk usage:"
           df -h

bootstrap.example.toml

@@ -758,12 +758,8 @@
 # Currently, the only standard options supported here are `"llvm"`, `"cranelift"` and `"gcc"`.
 #rust.codegen-backends = ["llvm"]
 
-# Indicates whether LLD will be compiled and made available in the sysroot for rustc to execute, and
-# whether to set it as rustc's default linker on `x86_64-unknown-linux-gnu`. This will also only be
-# when *not* building an external LLVM (so only when using `download-ci-llvm` or building LLVM from
-# the in-tree source): setting `llvm-config` in the `[target.x86_64-unknown-linux-gnu]` section will
-# make this default to false.
-#rust.lld = false in all cases, except on `x86_64-unknown-linux-gnu` as described above, where it is true
+# Indicates whether LLD will be compiled and made available in the sysroot for rustc to execute,
+#rust.lld = false, except for targets that opt into LLD (see `target.default-linker-linux-override`)
 
 # Indicates if we should override the linker used to link Rust crates during bootstrap to be LLD.
 # If set to `true` or `"external"`, a global `lld` binary that has to be in $PATH
@@ -1067,3 +1063,17 @@
 # Link the compiler and LLVM against `jemalloc` instead of the default libc allocator.
 # This overrides the global `rust.jemalloc` option. See that option for more info.
 #jemalloc = rust.jemalloc (bool)
+
+# The linker configuration that will *override* the default linker used for Linux
+# targets in the built compiler.
+#
+# The following values are supported:
+# - `off` => do not apply any override and use the default linker. This can be used to opt out of
+#   linker overrides set by bootstrap for specific targets (see below).
+# - `self-contained-lld-cc` => override the default linker to be self-contained LLD (`rust-lld`)
+#   that is invoked through `cc`.
+#
+# Currently, the following targets automatically opt into the self-contained LLD linker, unless you
+# pass `off`:
+# - x86_64-unknown-linux-gnu
+#default-linker-linux-override = "off" (for most targets)

compiler/rustc_ast/src/entry.rs

@@ -1,7 +1,5 @@
 use rustc_span::{Symbol, sym};
 
-use crate::attr::{self, AttributeExt};
-
 #[derive(Debug)]
 pub enum EntryPointType {
     /// This function is not an entrypoint.
@@ -30,11 +28,11 @@ pub enum EntryPointType {
 }
 
 pub fn entry_point_type(
-    attrs: &[impl AttributeExt],
+    has_rustc_main: bool,
     at_root: bool,
     name: Option<Symbol>,
 ) -> EntryPointType {
-    if attr::contains_name(attrs, sym::rustc_main) {
+    if has_rustc_main {
         EntryPointType::RustcMainAttr
     } else if let Some(name) = name
         && name == sym::main

compiler/rustc_ast/src/expand/allocator.rs

@@ -3,7 +3,9 @@ use rustc_span::{Symbol, sym};
 
 #[derive(Clone, Debug, Copy, Eq, PartialEq, HashStable_Generic)]
 pub enum AllocatorKind {
+    /// Use `#[global_allocator]` as global allocator.
     Global,
+    /// Use the default implementation in libstd as global allocator.
     Default,
 }
 
@@ -15,23 +17,22 @@ pub fn default_fn_name(base: Symbol) -> String {
     format!("__rdl_{base}")
 }
 
-pub fn alloc_error_handler_name(alloc_error_handler_kind: AllocatorKind) -> &'static str {
-    match alloc_error_handler_kind {
-        AllocatorKind::Global => "__rg_oom",
-        AllocatorKind::Default => "__rdl_oom",
-    }
-}
-
+pub const ALLOC_ERROR_HANDLER: Symbol = sym::alloc_error_handler;
 pub const NO_ALLOC_SHIM_IS_UNSTABLE: &str = "__rust_no_alloc_shim_is_unstable_v2";
 
+/// Argument or return type for methods in the allocator shim
+#[derive(Copy, Clone)]
 pub enum AllocatorTy {
     Layout,
+    Never,
     Ptr,
     ResultPtr,
     Unit,
     Usize,
 }
 
+/// A method that will be codegened in the allocator shim.
+#[derive(Copy, Clone)]
 pub struct AllocatorMethod {
     pub name: Symbol,
     pub inputs: &'static [AllocatorMethodInput],

compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs

@@ -1,9 +1,18 @@
 use super::prelude::*;
 use super::util::parse_single_integer;
 
-pub(crate) struct RustcLayoutScalarValidRangeStart;
+pub(crate) struct RustcMainParser;
 
-impl<S: Stage> SingleAttributeParser<S> for RustcLayoutScalarValidRangeStart {
+impl<S: Stage> NoArgsAttributeParser<S> for RustcMainParser {
+    const PATH: &'static [Symbol] = &[sym::rustc_main];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Fn)]);
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcMain;
+}
+
+pub(crate) struct RustcLayoutScalarValidRangeStartParser;
+
+impl<S: Stage> SingleAttributeParser<S> for RustcLayoutScalarValidRangeStartParser {
     const PATH: &'static [Symbol] = &[sym::rustc_layout_scalar_valid_range_start];
     const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
@@ -16,9 +25,9 @@ impl<S: Stage> SingleAttributeParser<S> for RustcLayoutScalarValidRangeStart {
     }
 }
 
-pub(crate) struct RustcLayoutScalarValidRangeEnd;
+pub(crate) struct RustcLayoutScalarValidRangeEndParser;
 
-impl<S: Stage> SingleAttributeParser<S> for RustcLayoutScalarValidRangeEnd {
+impl<S: Stage> SingleAttributeParser<S> for RustcLayoutScalarValidRangeEndParser {
     const PATH: &'static [Symbol] = &[sym::rustc_layout_scalar_valid_range_end];
     const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;

compiler/rustc_attr_parsing/src/context.rs

@@ -53,7 +53,7 @@ use crate::attributes::proc_macro_attrs::{
 use crate::attributes::prototype::CustomMirParser;
 use crate::attributes::repr::{AlignParser, AlignStaticParser, ReprParser};
 use crate::attributes::rustc_internal::{
-    RustcLayoutScalarValidRangeEnd, RustcLayoutScalarValidRangeStart,
+    RustcLayoutScalarValidRangeEndParser, RustcLayoutScalarValidRangeStartParser, RustcMainParser,
     RustcObjectLifetimeDefaultParser, RustcSimdMonomorphizeLaneLimitParser,
 };
 use crate::attributes::semantics::MayDangleParser;
@@ -197,8 +197,8 @@ attribute_parsers!(
         Single<RecursionLimitParser>,
         Single<RustcBuiltinMacroParser>,
         Single<RustcForceInlineParser>,
-        Single<RustcLayoutScalarValidRangeEnd>,
-        Single<RustcLayoutScalarValidRangeStart>,
+        Single<RustcLayoutScalarValidRangeEndParser>,
+        Single<RustcLayoutScalarValidRangeStartParser>,
         Single<RustcObjectLifetimeDefaultParser>,
         Single<RustcSimdMonomorphizeLaneLimitParser>,
         Single<SanitizeParser>,
@@ -238,6 +238,7 @@ attribute_parsers!(
         Single<WithoutArgs<ProcMacroParser>>,
         Single<WithoutArgs<PubTransparentParser>>,
         Single<WithoutArgs<RustcCoherenceIsCoreParser>>,
+        Single<WithoutArgs<RustcMainParser>>,
         Single<WithoutArgs<SpecializationTraitParser>>,
         Single<WithoutArgs<StdInternalSymbolParser>>,
         Single<WithoutArgs<TrackCallerParser>>,

compiler/rustc_borrowck/src/handle_placeholders.rs

@@ -344,7 +344,7 @@ pub(crate) fn compute_sccs_applying_placeholder_outlives_constraints<'tcx>(
     }
 }
 
-fn rewrite_placeholder_outlives<'tcx>(
+pub(crate) fn rewrite_placeholder_outlives<'tcx>(
     sccs: &Sccs<RegionVid, ConstraintSccIndex>,
     annotations: &SccAnnotations<'_, '_, RegionTracker>,
     fr_static: RegionVid,

compiler/rustc_borrowck/src/region_infer/opaque_types/member_constraints.rs

@@ -39,7 +39,7 @@ pub(super) fn apply_member_constraints<'tcx>(
     debug!(?member_constraints);
     for scc_a in rcx.constraint_sccs.all_sccs() {
         debug!(?scc_a);
-        // Start by  adding the region values required by outlives constraints. This
+        // Start by adding the region values required by outlives constraints. This
         // matches how we compute the final region values in `fn compute_regions`.
         //
         // We need to do this here to get a lower bound when applying member constraints.
@@ -64,6 +64,7 @@ fn apply_member_constraint<'tcx>(
     // If the member region lives in a higher universe, we currently choose
     // the most conservative option by leaving it unchanged.
     if !rcx.max_placeholder_universe_reached(member).is_root() {
+        debug!("member region reached non root universe, bailing");
         return;
     }
 

compiler/rustc_borrowck/src/region_infer/opaque_types/mod.rs

@@ -155,13 +155,6 @@ fn add_hidden_type<'tcx>(
     }
 }
 
-fn get_hidden_type<'tcx>(
-    hidden_types: &DefinitionSiteHiddenTypes<'tcx>,
-    def_id: LocalDefId,
-) -> Option<EarlyBinder<'tcx, OpaqueHiddenType<'tcx>>> {
-    hidden_types.0.get(&def_id).map(|ty| EarlyBinder::bind(*ty))
-}
-
 #[derive(Debug)]
 struct DefiningUse<'tcx> {
     /// The opaque type using non NLL vars. This uses the actual
@@ -253,6 +246,10 @@ fn collect_defining_uses<'tcx>(
                 }
             } else {
                 errors.push(DeferredOpaqueTypeError::InvalidOpaqueTypeArgs(err));
+                debug!(
+                    "collect_defining_uses: InvalidOpaqueTypeArgs for {:?} := {:?}",
+                    non_nll_opaque_type_key, hidden_type
+                );
             }
             continue;
         }
@@ -276,6 +273,7 @@ fn collect_defining_uses<'tcx>(
     defining_uses
 }
 
+#[instrument(level = "debug", skip(rcx, hidden_types, defining_uses, errors))]
 fn compute_definition_site_hidden_types_from_defining_uses<'tcx>(
     rcx: &RegionCtxt<'_, 'tcx>,
     hidden_types: &mut DefinitionSiteHiddenTypes<'tcx>,
@@ -287,13 +285,15 @@ fn compute_definition_site_hidden_types_from_defining_uses<'tcx>(
     let mut decls_modulo_regions: FxIndexMap<OpaqueTypeKey<'tcx>, (OpaqueTypeKey<'tcx>, Span)> =
         FxIndexMap::default();
     for &DefiningUse { opaque_type_key, ref arg_regions, hidden_type } in defining_uses {
+        debug!(?opaque_type_key, ?arg_regions, ?hidden_type);
         // After applying member constraints, we now map all regions in the hidden type
         // to the `arg_regions` of this defining use. In case a region in the hidden type
         // ended up not being equal to any such region, we error.
         let hidden_type =
             match hidden_type.try_fold_with(&mut ToArgRegionsFolder::new(rcx, arg_regions)) {
                 Ok(hidden_type) => hidden_type,
                 Err(r) => {
+                    debug!("UnexpectedHiddenRegion: {:?}", r);
                     errors.push(DeferredOpaqueTypeError::UnexpectedHiddenRegion {
                         hidden_type,
                         opaque_type_key,
@@ -501,7 +501,8 @@ pub(crate) fn apply_definition_site_hidden_types<'tcx>(
     let tcx = infcx.tcx;
     let mut errors = Vec::new();
     for &(key, hidden_type) in opaque_types {
-        let Some(expected) = get_hidden_type(hidden_types, key.def_id) else {
+        let Some(expected) = hidden_types.0.get(&key.def_id).map(|ty| EarlyBinder::bind(*ty))
+        else {
             if !tcx.use_typing_mode_borrowck() {
                 if let ty::Alias(ty::Opaque, alias_ty) = hidden_type.ty.kind()
                     && alias_ty.def_id == key.def_id.to_def_id()

compiler/rustc_borrowck/src/region_infer/opaque_types/region_ctxt.rs

@@ -11,7 +11,9 @@ use crate::constraints::ConstraintSccIndex;
 use crate::handle_placeholders::{SccAnnotations, region_definitions};
 use crate::region_infer::reverse_sccs::ReverseSccGraph;
 use crate::region_infer::values::RegionValues;
-use crate::region_infer::{ConstraintSccs, RegionDefinition, RegionTracker, Representative};
+use crate::region_infer::{
+    ConstraintSccs, OutlivesConstraintSet, RegionDefinition, RegionTracker, Representative,
+};
 use crate::type_check::MirTypeckRegionConstraints;
 use crate::type_check::free_region_relations::UniversalRegionRelations;
 use crate::universal_regions::UniversalRegions;
@@ -39,16 +41,36 @@ impl<'a, 'tcx> RegionCtxt<'a, 'tcx> {
         location_map: Rc<DenseLocationMap>,
         constraints: &MirTypeckRegionConstraints<'tcx>,
     ) -> RegionCtxt<'a, 'tcx> {
+        let mut outlives_constraints = constraints.outlives_constraints.clone();
         let universal_regions = &universal_region_relations.universal_regions;
         let (definitions, _has_placeholders) = region_definitions(infcx, universal_regions);
+
+        let compute_sccs =
+            |outlives_constraints: &OutlivesConstraintSet<'tcx>,
+             annotations: &mut SccAnnotations<'_, 'tcx, RegionTracker>| {
+                ConstraintSccs::new_with_annotation(
+                    &outlives_constraints
+                        .graph(definitions.len())
+                        .region_graph(outlives_constraints, universal_regions.fr_static),
+                    annotations,
+                )
+            };
+
         let mut scc_annotations = SccAnnotations::init(&definitions);
-        let constraint_sccs = ConstraintSccs::new_with_annotation(
-            &constraints
-                .outlives_constraints
-                .graph(definitions.len())
-                .region_graph(&constraints.outlives_constraints, universal_regions.fr_static),
-            &mut scc_annotations,
+        let mut constraint_sccs = compute_sccs(&outlives_constraints, &mut scc_annotations);
+
+        let added_constraints = crate::handle_placeholders::rewrite_placeholder_outlives(
+            &constraint_sccs,
+            &scc_annotations,
+            universal_regions.fr_static,
+            &mut outlives_constraints,
         );
+
+        if added_constraints {
+            scc_annotations = SccAnnotations::init(&definitions);
+            constraint_sccs = compute_sccs(&outlives_constraints, &mut scc_annotations);
+        }
+
         let scc_annotations = scc_annotations.scc_to_annotation;
 
         // Unlike the `RegionInferenceContext`, we only care about free regions