Auto merge of #127466 - compiler-errors:adt-flags, r=<try>

Encode ADT flags rather than recreating them from scratch at decoding time

r? lcnr

Author: bors

compiler/rustc_feature/src/builtin_attrs.rs

@@ -654,7 +654,7 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
     // Internal attributes: Type system related:
     // ==========================================================================
 
-    gated!(fundamental, Normal, template!(Word), WarnFollowing, EncodeCrossCrate::Yes, experimental!(fundamental)),
+    gated!(fundamental, Normal, template!(Word), WarnFollowing, EncodeCrossCrate::No, experimental!(fundamental)),
     gated!(
         may_dangle, Normal, template!(Word), WarnFollowing,
         EncodeCrossCrate::No, dropck_eyepatch,

compiler/rustc_hir_analysis/src/collect.rs

@@ -1180,7 +1180,7 @@ fn adt_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::AdtDef<'_> {
         }
         _ => bug!("{:?} is not an ADT", item.owner_id.def_id),
     };
-    tcx.mk_adt_def(def_id.to_def_id(), kind, variants, repr, is_anonymous)
+    tcx.mk_adt_def(def_id, kind, variants, repr, is_anonymous)
 }
 
 fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
@@ -1201,6 +1201,7 @@ fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
 
     let is_marker = tcx.has_attr(def_id, sym::marker);
     let rustc_coinductive = tcx.has_attr(def_id, sym::rustc_coinductive);
+    let is_fundamental = tcx.has_attr(def_id, sym::fundamental);
 
     // FIXME: We could probably do way better attribute validation here.
     let mut skip_array_during_method_dispatch = false;
@@ -1352,6 +1353,7 @@ fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
         has_auto_impl: is_auto,
         is_marker,
         is_coinductive: rustc_coinductive || is_auto,
+        is_fundamental,
         skip_array_during_method_dispatch,
         skip_boxed_slice_during_method_dispatch,
         specialization_kind,

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -1151,7 +1151,9 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
             DefKind::Union => ty::AdtKind::Union,
             _ => bug!("get_adt_def called on a non-ADT {:?}", did),
         };
+
         let repr = self.root.tables.repr_options.get(self, item_id).unwrap().decode(self);
+        let flags = self.root.tables.adt_flags.get(self, item_id).unwrap().decode(self);
 
         let mut variants: Vec<_> = if let ty::AdtKind::Enum = adt_kind {
             self.root
@@ -1174,12 +1176,11 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
 
         variants.sort_by_key(|(idx, _)| *idx);
 
-        tcx.mk_adt_def(
+        tcx.mk_adt_def_from_flags(
             did,
-            adt_kind,
             variants.into_iter().map(|(_, variant)| variant).collect(),
+            flags,
             repr,
-            false,
         )
     }
 

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -1533,6 +1533,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         let tcx = self.tcx;
         let adt_def = tcx.adt_def(def_id);
         record!(self.tables.repr_options[def_id] <- adt_def.repr());
+        record!(self.tables.adt_flags[def_id] <- adt_def.flags());
 
         let params_in_repr = self.tcx.params_in_repr(def_id);
         record!(self.tables.params_in_repr[def_id] <- params_in_repr);

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -452,6 +452,7 @@ define_tables! {
     expn_that_defined: Table<DefIndex, LazyValue<ExpnId>>,
     params_in_repr: Table<DefIndex, LazyValue<BitSet<u32>>>,
     repr_options: Table<DefIndex, LazyValue<ReprOptions>>,
+    adt_flags: Table<DefIndex, LazyValue<ty::AdtFlags>>,
     // `def_keys` and `def_path_hashes` represent a lazy version of a
     // `DefPathTable`. This allows us to avoid deserializing an entire
     // `DefPathTable` up front, since we may only ever use a few

compiler/rustc_middle/src/ty/adt.rs

@@ -9,7 +9,7 @@ use rustc_data_structures::stable_hasher::HashingControls;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir::def::{CtorKind, DefKind, Res};
-use rustc_hir::def_id::DefId;
+use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::{self as hir, LangItem};
 use rustc_index::{IndexSlice, IndexVec};
 use rustc_macros::{HashStable, TyDecodable, TyEncodable};
@@ -249,15 +249,25 @@ impl Into<DataTypeKind> for AdtKind {
 }
 
 impl AdtDefData {
+    pub(super) fn new_from_flags(
+        did: DefId,
+        variants: IndexVec<VariantIdx, VariantDef>,
+        flags: AdtFlags,
+        repr: ReprOptions,
+    ) -> Self {
+        AdtDefData { did, variants, flags, repr }
+    }
+
     /// Creates a new `AdtDefData`.
     pub(super) fn new(
         tcx: TyCtxt<'_>,
-        did: DefId,
+        did: LocalDefId,
         kind: AdtKind,
         variants: IndexVec<VariantIdx, VariantDef>,
         repr: ReprOptions,
         is_anonymous: bool,
     ) -> Self {
+        let did = did.to_def_id();
         debug!(
             "AdtDef::new({:?}, {:?}, {:?}, {:?}, {:?})",
             did, kind, variants, repr, is_anonymous

compiler/rustc_middle/src/ty/context.rs

@@ -1393,9 +1393,19 @@ impl<'tcx> TyCtxt<'tcx> {
         self.arena.alloc(Steal::new(promoted))
     }
 
-    pub fn mk_adt_def(
+    pub fn mk_adt_def_from_flags(
         self,
         did: DefId,
+        variants: IndexVec<VariantIdx, ty::VariantDef>,
+        flags: ty::AdtFlags,
+        repr: ReprOptions,
+    ) -> ty::AdtDef<'tcx> {
+        self.mk_adt_def_from_data(ty::AdtDefData::new_from_flags(did, variants, flags, repr))
+    }
+
+    pub fn mk_adt_def(
+        self,
+        did: LocalDefId,
         kind: AdtKind,
         variants: IndexVec<VariantIdx, ty::VariantDef>,
         repr: ReprOptions,

compiler/rustc_middle/src/ty/parameterized.rs

@@ -63,6 +63,7 @@ trivially_parameterized_over_tcx! {
     crate::middle::lib_features::FeatureStability,
     crate::middle::resolve_bound_vars::ObjectLifetimeDefault,
     crate::mir::ConstQualifs,
+    ty::AdtFlags,
     ty::AssocItemContainer,
     ty::Asyncness,
     ty::DeducedParamAttrs,

compiler/rustc_middle/src/ty/trait_def.rs

@@ -31,7 +31,7 @@ pub struct TraitDef {
     /// and thus `impl`s of it are allowed to overlap.
     pub is_marker: bool,
 
-    /// If `true`, then this trait has to `#[rustc_coinductive]` attribute or
+    /// If `true`, then this trait has the `#[rustc_coinductive]` attribute or
     /// is an auto trait. This indicates that trait solver cycles involving an
     /// `X: ThisTrait` goal are accepted.
     ///
@@ -40,6 +40,11 @@ pub struct TraitDef {
     /// also have already switched to the new trait solver.
     pub is_coinductive: bool,
 
+    /// If `true`, then this trait has the `#[fundamental]` attribute. This
+    /// affects how conherence computes whether a trait may have trait implementations
+    /// added in the future.
+    pub is_fundamental: bool,
+
     /// If `true`, then this trait has the `#[rustc_skip_during_method_dispatch(array)]`
     /// attribute, indicating that editions before 2021 should not consider this trait
     /// during method dispatch if the receiver is an array.

compiler/rustc_trait_selection/src/traits/coherence.rs

@@ -666,7 +666,7 @@ pub fn trait_ref_is_local_or_fundamental<'tcx>(
     tcx: TyCtxt<'tcx>,
     trait_ref: ty::TraitRef<'tcx>,
 ) -> bool {
-    trait_ref.def_id.is_local() || tcx.has_attr(trait_ref.def_id, sym::fundamental)
+    trait_ref.def_id.is_local() || tcx.trait_def(trait_ref.def_id).is_fundamental
 }
 
 #[derive(Debug, Copy, Clone)]