Forbid simultaneously defining *and* opaquely using TAITs within bodies

Author: oli-obk

compiler/rustc_hir_analysis/src/collect/type_of/opaque.rs

@@ -229,17 +229,16 @@ impl TaitConstraintLocator<'_> {
             return;
         }
 
-        let opaques = self.tcx.opaque_types_defined_by(item_def_id);
-        let opaque_type_must_be_defined = opaques.in_signature.contains(&self.def_id);
-        let opaque_type_may_be_defined = opaques.in_body.contains(&self.def_id);
+        let opaque_types_defined_by = self.tcx.opaque_types_defined_by(item_def_id);
 
         let mut constrained = false;
         for (&opaque_type_key, &hidden_type) in &tables.concrete_opaque_types {
             if opaque_type_key.def_id != self.def_id {
                 continue;
             }
             constrained = true;
-            if !opaque_type_must_be_defined && !opaque_type_may_be_defined {
+
+            if !opaque_types_defined_by.contains(&self.def_id) {
                 self.tcx.dcx().emit_err(TaitForwardCompat {
                     span: hidden_type.span,
                     item_span: self
@@ -261,7 +260,7 @@ impl TaitConstraintLocator<'_> {
 
         if !constrained {
             debug!("no constraints in typeck results");
-            if opaque_type_must_be_defined {
+            if opaque_types_defined_by.contains(&self.def_id) {
                 self.tcx.dcx().emit_err(TaitForwardCompat2 {
                     span: self
                         .tcx

compiler/rustc_infer/src/infer/error_reporting/note_and_explain.rs

@@ -362,10 +362,9 @@ impl<T> Trait<T> for X {
                                     | DefKind::AssocConst
                             )
                             && tcx.is_type_alias_impl_trait(opaque_ty.def_id)
-                            && let opaques =
-                                tcx.opaque_types_defined_by(body_owner_def_id.expect_local())
-                            && !opaques.in_body.contains(&opaque_ty.def_id.expect_local())
-                            && !opaques.in_signature.contains(&opaque_ty.def_id.expect_local())
+                            && !tcx
+                                .opaque_types_defined_by(body_owner_def_id.expect_local())
+                                .contains(&opaque_ty.def_id.expect_local())
                         {
                             let sp = tcx
                                 .def_ident_span(body_owner_def_id)
@@ -433,7 +432,6 @@ impl<T> Trait<T> for X {
                             }
                         }
                     }
-
                     (ty::FnPtr(sig), ty::FnDef(def_id, _))
                     | (ty::FnDef(def_id, _), ty::FnPtr(sig)) => {
                         if tcx.fn_sig(def_id).skip_binder().safety() < sig.safety() {

compiler/rustc_infer/src/infer/mod.rs

@@ -243,7 +243,7 @@ pub struct InferCtxt<'tcx> {
     pub tcx: TyCtxt<'tcx>,
 
     /// The `DefIds` of the opaque types that may have their hidden types constrained.
-    defining_opaque_types: ty::OpaqueTypes<'tcx>,
+    defining_opaque_types: &'tcx ty::List<LocalDefId>,
 
     /// Whether this inference context should care about region obligations in
     /// the root universe. Most notably, this is used during hir typeck as region
@@ -370,7 +370,7 @@ impl<'tcx> ty::InferCtxtLike for InferCtxt<'tcx> {
         self.inner.borrow_mut().unwrap_region_constraints().opportunistic_resolve_var(self.tcx, vid)
     }
 
-    fn defining_opaque_types(&self) -> ty::OpaqueTypes<'tcx> {
+    fn defining_opaque_types(&self) -> &'tcx ty::List<LocalDefId> {
         self.defining_opaque_types
     }
 
@@ -620,7 +620,7 @@ impl fmt::Display for FixupError {
 /// Used to configure inference contexts before their creation.
 pub struct InferCtxtBuilder<'tcx> {
     tcx: TyCtxt<'tcx>,
-    defining_opaque_types: ty::OpaqueTypes<'tcx>,
+    defining_opaque_types: &'tcx ty::List<LocalDefId>,
     considering_regions: bool,
     skip_leak_check: bool,
     /// Whether we are in coherence mode.
@@ -635,7 +635,7 @@ impl<'tcx> TyCtxt<'tcx> {
     fn infer_ctxt(self) -> InferCtxtBuilder<'tcx> {
         InferCtxtBuilder {
             tcx: self,
-            defining_opaque_types: Default::default(),
+            defining_opaque_types: ty::List::empty(),
             considering_regions: true,
             skip_leak_check: false,
             intercrate: false,
@@ -651,14 +651,14 @@ impl<'tcx> InferCtxtBuilder<'tcx> {
     /// It is only meant to be called in two places, for typeck
     /// (via `Inherited::build`) and for the inference context used
     /// in mir borrowck.
-    pub fn with_opaque_type_inference(self, defining_anchor: LocalDefId) -> Self {
-        let defining_opaque_types = self.tcx.opaque_types_defined_by(defining_anchor);
-        self.with_defining_opaque_types(defining_opaque_types)
+    pub fn with_opaque_type_inference(mut self, defining_anchor: LocalDefId) -> Self {
+        self.defining_opaque_types = self.tcx.opaque_types_defined_by(defining_anchor);
+        self
     }
 
     pub fn with_defining_opaque_types(
         mut self,
-        defining_opaque_types: ty::OpaqueTypes<'tcx>,
+        defining_opaque_types: &'tcx ty::List<LocalDefId>,
     ) -> Self {
         self.defining_opaque_types = defining_opaque_types;
         self
@@ -1213,8 +1213,7 @@ impl<'tcx> InferCtxt<'tcx> {
     #[inline(always)]
     pub fn can_define_opaque_ty(&self, id: impl Into<DefId>) -> bool {
         let Some(id) = id.into().as_local() else { return false };
-        self.defining_opaque_types.in_signature.contains(&id)
-            || self.defining_opaque_types.in_body.contains(&id)
+        self.defining_opaque_types.contains(&id)
     }
 
     pub fn ty_to_string(&self, t: Ty<'tcx>) -> String {

compiler/rustc_middle/src/infer/canonical.rs

@@ -182,7 +182,7 @@ impl<'tcx> CanonicalParamEnvCache<'tcx> {
                 max_universe: ty::UniverseIndex::ROOT,
                 variables: List::empty(),
                 value: key,
-                defining_opaque_types: Default::default(),
+                defining_opaque_types: ty::List::empty(),
             };
         }
 

compiler/rustc_middle/src/query/erase.rs

@@ -183,10 +183,6 @@ impl EraseType for Option<mir::DestructuredConstant<'_>> {
     type Result = [u8; size_of::<Option<mir::DestructuredConstant<'static>>>()];
 }
 
-impl EraseType for ty::OpaqueTypes<'_> {
-    type Result = [u8; size_of::<ty::OpaqueTypes<'static>>()];
-}
-
 impl EraseType for Option<ty::ImplTraitHeader<'_>> {
     type Result = [u8; size_of::<Option<ty::ImplTraitHeader<'static>>>()];
 }

compiler/rustc_middle/src/query/mod.rs

@@ -337,7 +337,7 @@ rustc_queries! {
 
     query opaque_types_defined_by(
         key: LocalDefId
-    ) -> ty::OpaqueTypes<'tcx> {
+    ) -> &'tcx ty::List<LocalDefId> {
         desc {
             |tcx| "computing the opaque types defined by `{}`",
             tcx.def_path_str(key.to_def_id())

compiler/rustc_middle/src/query/plumbing.rs

@@ -325,7 +325,7 @@ macro_rules! define_callbacks {
                 // Increase this limit if necessary, but do try to keep the size low if possible
                 #[cfg(target_pointer_width = "64")]
                 const _: () = {
-                    if mem::size_of::<Key<'static>>() > 80 {
+                    if mem::size_of::<Key<'static>>() > 72 {
                         panic!("{}", concat!(
                             "the query `",
                             stringify!($name),
@@ -340,7 +340,7 @@ macro_rules! define_callbacks {
                 // Increase this limit if necessary, but do try to keep the size low if possible
                 #[cfg(target_pointer_width = "64")]
                 const _: () = {
-                    if mem::size_of::<Value<'static>>() > 72 {
+                    if mem::size_of::<Value<'static>>() > 64 {
                         panic!("{}", concat!(
                             "the query `",
                             stringify!($name),

compiler/rustc_middle/src/ty/context.rs

@@ -100,7 +100,7 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
 
     type CanonicalVars = CanonicalVarInfos<'tcx>;
     type PredefinedOpaques = solve::PredefinedOpaques<'tcx>;
-    type DefiningOpaqueTypes = ty::OpaqueTypes<'tcx>;
+    type DefiningOpaqueTypes = &'tcx ty::List<LocalDefId>;
     type ExternalConstraints = ExternalConstraints<'tcx>;
     type CanonicalGoalEvaluationStepRef =
         &'tcx solve::inspect::CanonicalGoalEvaluationStep<TyCtxt<'tcx>>;

compiler/rustc_middle/src/ty/mod.rs

@@ -31,7 +31,6 @@ pub use assoc::*;
 pub use generic_args::{GenericArgKind, TermKind, *};
 pub use generics::*;
 pub use intrinsic::IntrinsicDef;
-pub use opaque_types::OpaqueTypes;
 use rustc_ast as ast;
 use rustc_ast::expand::StrippedCfgItem;
 use rustc_ast::node_id::NodeMap;

compiler/rustc_middle/src/ty/opaque_types.rs

@@ -3,8 +3,7 @@ use crate::ty::fold::{TypeFolder, TypeSuperFoldable};
 use crate::ty::{self, Ty, TyCtxt, TypeFoldable};
 use crate::ty::{GenericArg, GenericArgKind};
 use rustc_data_structures::fx::FxHashMap;
-use rustc_macros::{HashStable, TyDecodable, TyEncodable, TypeVisitable};
-use rustc_span::def_id::{DefId, LocalDefId};
+use rustc_span::def_id::DefId;
 use rustc_span::Span;
 use tracing::{debug, instrument, trace};
 
@@ -226,14 +225,3 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for ReverseMapper<'tcx> {
         }
     }
 }
-
-/// The opaque types defined by an item.
-#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq, Default)]
-#[derive(HashStable, TypeVisitable, TypeFoldable, TyDecodable, TyEncodable)]
-pub struct OpaqueTypes<'tcx> {
-    /// Opaque types in the signature *must* be defined by the item itself.
-    pub in_signature: &'tcx ty::List<LocalDefId>,
-    /// Opaque types declared in the body are not required to be defined by
-    /// the item itself, they could be defined by other nested items.
-    pub in_body: &'tcx ty::List<LocalDefId>,
-}

compiler/rustc_ty_utils/src/opaque_types.rs

@@ -119,8 +119,7 @@ impl<'tcx> OpaqueTypeCollector<'tcx> {
                 let id = id.owner_id.def_id;
                 if let DefKind::TyAlias = self.collector.tcx.def_kind(id) {
                     let items = self.collector.tcx.opaque_types_defined_by(id);
-                    assert_eq!(&items.in_body[..], []);
-                    self.collector.opaques.extend(items.in_signature);
+                    self.collector.opaques.extend(items);
                 }
             }
             #[instrument(level = "trace", skip(self))]
@@ -313,20 +312,22 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for OpaqueTypeCollector<'tcx> {
     }
 }
 
-fn opaque_types_defined_by<'tcx>(tcx: TyCtxt<'tcx>, item: LocalDefId) -> ty::OpaqueTypes<'tcx> {
+fn opaque_types_defined_by<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    item: LocalDefId,
+) -> &'tcx ty::List<LocalDefId> {
     let kind = tcx.def_kind(item);
     trace!(?kind);
-    let mut in_signature = OpaqueTypeCollector::new(tcx, item);
-    let mut in_body = OpaqueTypeCollector::new(tcx, item);
-    super::sig_types::walk_types(tcx, item, &mut in_signature);
+    let mut collector = OpaqueTypeCollector::new(tcx, item);
+    super::sig_types::walk_types(tcx, item, &mut collector);
     match kind {
         DefKind::AssocFn
         | DefKind::Fn
         | DefKind::Static { .. }
         | DefKind::Const
         | DefKind::AssocConst
         | DefKind::AnonConst => {
-            in_body.collect_taits_declared_in_body();
+            collector.collect_taits_declared_in_body();
         }
         DefKind::OpaqueTy
         | DefKind::TyAlias
@@ -353,15 +354,10 @@ fn opaque_types_defined_by<'tcx>(tcx: TyCtxt<'tcx>, item: LocalDefId) -> ty::Opa
         // Closures and coroutines are type checked with their parent, so we need to allow all
         // opaques from the closure signature *and* from the parent body.
         DefKind::Closure | DefKind::InlineConst => {
-            let nested = tcx.opaque_types_defined_by(tcx.local_parent(item));
-            in_signature.opaques.extend(nested.in_signature);
-            in_body.opaques.extend(nested.in_body);
+            collector.opaques.extend(tcx.opaque_types_defined_by(tcx.local_parent(item)));
         }
     }
-    ty::OpaqueTypes {
-        in_signature: tcx.mk_local_def_ids(&in_signature.opaques),
-        in_body: tcx.mk_local_def_ids(&in_body.opaques),
-    }
+    tcx.mk_local_def_ids(&collector.opaques)
 }
 
 pub(super) fn provide(providers: &mut Providers) {