Rollup of 11 pull requests

compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs

@@ -610,7 +610,7 @@ impl<'tcx> MirBorrowckCtxt<'_, '_, 'tcx> {
             // loop iteration. In this case, try using the loop terminator location in
             // `find_sub_region_live_at`.
             if let Some(loop_terminator_location) =
-                regioncx.find_loop_terminator_location(borrow.region, body)
+                regioncx.find_loop_terminator_location(borrow.region, body, location)
             {
                 region_sub = self
                     .regioncx

compiler/rustc_borrowck/src/region_infer/region_context.rs

@@ -816,16 +816,19 @@ impl<'tcx> RegionInferenceContextInner<'tcx> {
         &self,
         r: RegionVid,
         body: &Body<'_>,
+        from_location: Location,
     ) -> Option<Location> {
         let scc = self.constraint_sccs.scc(r);
         let locations = self.scc_values.locations_outlived_by(scc);
         for location in locations {
-            let bb = &body[location.block];
-            if let Some(terminator) = &bb.terminator
+            if from_location.is_predecessor_of(location, body) {
+                let bb = &body[location.block];
+                if let Some(terminator) = &bb.terminator
                 // terminator of a loop should be TerminatorKind::FalseUnwind
                 && let TerminatorKind::FalseUnwind { .. } = terminator.kind
-            {
-                return Some(location);
+                {
+                    return Some(location);
+                }
             }
         }
         None

compiler/rustc_hir_id/src/definitions.rs

@@ -98,6 +98,9 @@ pub struct Definitions {
     def_id_to_key: IndexVec<LocalDefId, DefKey>,
     // We do only store the local hash, as all the definitions are from the current crate.
     def_path_hashes: IndexVec<LocalDefId, Hash64>,
+    // The first non deterministic def index, may correspond to non-allocated
+    // def id, in this case `first_non_det_index.as_usize() == num_definitions`.
+    first_non_det_index: Option<DefIndex>,
     def_path_hash_to_index: DefPathToIndexMap,
 }
 
@@ -302,13 +305,18 @@ pub enum DefPathData {
 }
 
 impl Definitions {
-    /// This function indicates that the order of def id allocations
+    /// This function indicates that the def id allocations
     /// may be non-deterministic after it was called.
     pub fn commit_end_of_determinism(&mut self) {
-        assert!(
-            self.def_path_hash_to_index.after_parallel_alloc.replace(Default::default()).is_none(),
-            "this function should be called only once"
-        )
+        let prev = self.def_path_hash_to_index.after_parallel_alloc.replace(Default::default());
+        assert!(prev.is_none(), "this function should be called only once");
+
+        let def_index = DefIndex::from_usize(self.def_id_to_key.len());
+        self.first_non_det_index.replace(def_index);
+    }
+
+    pub fn first_non_det_index(&self) -> DefIndex {
+        self.first_non_det_index.expect("must contain index")
     }
 
     #[inline(always)]
@@ -362,6 +370,7 @@ impl Definitions {
             def_path_hashes: Default::default(),
             def_id_to_key: Default::default(),
             def_path_hash_to_index: Default::default(),
+            first_non_det_index: Default::default(),
         };
 
         // Create the root definition.

compiler/rustc_interface/src/limits.rs

@@ -8,28 +8,51 @@
 //! Users can override these limits via an attribute on the crate like
 //! `#![recursion_limit="22"]`. This pass just looks for those attributes.
 
+use rustc_ast::{self as ast, DUMMY_NODE_ID};
+use rustc_attr_ir::target::Target;
 use rustc_attr_ir::{Attribute, find_attr};
-use rustc_middle::query::Providers;
+use rustc_attr_parsing::{AttributeParser, ShouldEmit};
+use rustc_feature::Features;
 use rustc_session::{Limits, Session};
+use rustc_span::{DUMMY_SP, sym};
 use rustc_structures::Limit;
 
-pub(crate) fn provide(providers: &mut Providers) {
-    providers.limits = |tcx, ()| {
-        let attrs = tcx.hir_krate_attrs();
-        Limits {
-            recursion_limit: get_recursion_limit(tcx.hir_krate_attrs(), tcx.sess),
-            move_size_limit: find_attr!(attrs, MoveSizeLimit { limit } => *limit)
-                .unwrap_or(Limit::new(tcx.sess.opts.unstable_opts.move_size_limit.unwrap_or(0))),
-            type_length_limit: find_attr!(attrs, TypeLengthLimit { limit } => *limit)
-                .unwrap_or(Limit::new(2usize.pow(24))),
-            pattern_complexity_limit: find_attr!(attrs, PatternComplexityLimit { limit } => *limit)
-                .unwrap_or(Limit::unlimited()),
-        }
+pub fn get_limits(krate_attrs: &[ast::Attribute], sess: &Session, features: &Features) -> Limits {
+    let attrs = AttributeParser::parse_limited_all(
+        sess,
+        &krate_attrs,
+        Some(&|attr| {
+            attr.has_any_name(&[
+                sym::recursion_limit,
+                sym::move_size_limit,
+                sym::type_length_limit,
+                sym::pattern_complexity_limit,
+            ])
+        }),
+        Target::Crate,
+        DUMMY_SP,
+        DUMMY_NODE_ID,
+        Some(features),
+        // errors are fatal here, but lints aren't.
+        // If things aren't fatal we continue, and will parse this again.
+        // That makes the same lint trigger again.
+        // So, no lints here to avoid duplicates.
+        ShouldEmit::EarlyFatal { also_emit_lints: false },
+        None,
+    );
+    let attrs = &attrs;
+    Limits {
+        recursion_limit: get_recursion_limit(attrs, sess),
+        move_size_limit: find_attr!(attrs, MoveSizeLimit { limit } => *limit)
+            .unwrap_or(Limit::new(sess.opts.unstable_opts.move_size_limit.unwrap_or(0))),
+        type_length_limit: find_attr!(attrs, TypeLengthLimit { limit } => *limit)
+            .unwrap_or(Limit::new(2usize.pow(24))),
+        pattern_complexity_limit: find_attr!(attrs, PatternComplexityLimit { limit } => *limit)
+            .unwrap_or(Limit::unlimited()),
     }
 }
 
-// This one is separate because it must be read prior to macro expansion.
-pub(crate) fn get_recursion_limit(attrs: &[Attribute], sess: &Session) -> Limit {
+fn get_recursion_limit(attrs: &[Attribute], sess: &Session) -> Limit {
     let limit_from_crate = find_attr!(attrs, RecursionLimit { limit } => limit.0).unwrap_or(128);
     Limit::new(
         sess.opts

compiler/rustc_interface/src/passes.rs

@@ -44,7 +44,7 @@ use rustc_session::{IncrCompSession, Session};
 use rustc_span::{
     DUMMY_SP, ErrorGuaranteed, ExpnKind, SourceFileHash, SourceFileHashAlgorithm, Span, Symbol, sym,
 };
-use rustc_structures::{CrateType, Limit};
+use rustc_structures::CrateType;
 use rustc_trait_selection::{solve, traits};
 use tracing::{info, instrument};
 
@@ -201,7 +201,7 @@ fn configure_and_expand(
         }
 
         // Create the config for macro expansion
-        let recursion_limit = get_recursion_limit(pre_configured_attrs, sess);
+        let recursion_limit = tcx.recursion_limit();
         let cfg = rustc_expand::expand::ExpansionConfig {
             crate_name,
             features,
@@ -905,7 +905,6 @@ pub static DEFAULT_QUERY_PROVIDERS: LazyLock<Providers> = LazyLock::new(|| {
     providers.queries.env_var_os = env_var_os;
     providers.queries.proc_macro_decls_static = |tcx, _| tcx.hir_crate_items(()).proc_macro_decls();
     rustc_ast_lowering::provide(&mut providers.queries);
-    limits::provide(&mut providers.queries);
     rustc_expand_queries::provide(&mut providers.queries);
     rustc_const_eval::provide(providers);
     rustc_middle::hir::provide(&mut providers.queries);
@@ -1037,11 +1036,13 @@ pub fn create_and_enter_global_ctxt<T, F: for<'tcx> FnOnce(TyCtxt<'tcx>) -> T>(
             feed.crate_name(crate_name);
 
             let feed = tcx.feed_unit_query();
-            feed.features_query(tcx.arena.alloc(rustc_expand::config::features(
+            let features = tcx.arena.alloc(rustc_expand::config::features(
                 tcx.sess,
                 &pre_configured_attrs,
                 crate_name,
-            )));
+            ));
+            feed.features_query(features);
+            feed.limits(limits::get_limits(&pre_configured_attrs, tcx.sess, features));
             feed.crate_for_resolver(tcx.arena.alloc(Steal::new((krate, pre_configured_attrs))));
             feed.output_filenames(Arc::new(outputs));
 
@@ -1523,19 +1524,3 @@ pub fn collect_crate_types(
 fn default_output_for_target(sess: &Session) -> CrateType {
     if !sess.target.executables { CrateType::StaticLib } else { CrateType::Executable }
 }
-
-fn get_recursion_limit(krate_attrs: &[ast::Attribute], sess: &Session) -> Limit {
-    let attr = AttributeParser::parse_limited_sym_should_emit(
-        sess,
-        &krate_attrs,
-        &[sym::recursion_limit],
-        DUMMY_SP,
-        None,
-        // errors are fatal here, but lints aren't.
-        // If things aren't fatal we continue, and will parse this again.
-        // That makes the same lint trigger again.
-        // So, no lints here to avoid duplicates.
-        ShouldEmit::EarlyFatal { also_emit_lints: false },
-    );
-    crate::limits::get_recursion_limit(attr.as_slice(), sess)
-}

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -41,6 +41,7 @@ use tracing::debug;
 
 use crate::creader::CStore;
 use crate::eii::EiiMapEncodedKeyValue;
+use crate::rmeta::remapped_def_id::RemappedRawDefId;
 use crate::rmeta::table::IsDefault;
 use crate::rmeta::*;
 
@@ -103,7 +104,7 @@ pub(crate) struct CrateMetadata {
     /// FIXME: make type of the value `LazyArray<(DefIndex, Option<SimplifiedType>)>`
     /// through transmuting or somehow else, as `LocalDefId` here should be `DefIndex`,
     /// as it is from external crate.
-    trait_impls: FxIndexMap<RawDefId, LazyArray<(LocalDefId, Option<SimplifiedType>)>>,
+    trait_impls: FxIndexMap<RemappedRawDefId, LazyArray<(LocalDefId, Option<SimplifiedType>)>>,
     /// Inherent impls which do not follow the normal coherence rules.
     ///
     /// These can be introduced using either `#![rustc_coherence_is_core]`
@@ -2163,10 +2164,10 @@ impl CrateMetadata {
 
     // Translate a DefId from the current compilation environment to a DefId
     // for an external crate.
-    fn reverse_translate_def_id(&self, did: DefId) -> Option<RawDefId> {
+    fn reverse_translate_def_id(&self, did: DefId) -> Option<RemappedRawDefId> {
         for (local, &global) in self.cnum_map.iter_enumerated() {
             if global == did.krate {
-                return Some(RawDefId { krate: local.as_u32(), index: did.index.as_u32() });
+                return Some(RemappedRawDefId::new_unchecked(local.as_u32(), did.index.as_u32()));
             }
         }