Move almost all methods on Interner to RustIr

Author: jackh726

Diff for: compiler/rustc_middle/src/ty/adt.rs

@@ -18,7 +18,6 @@ use rustc_macros::{HashStable, TyDecodable, TyEncodable};
 use rustc_query_system::ich::StableHashingContext;
 use rustc_session::DataTypeKind;
 use rustc_span::symbol::sym;
-use rustc_type_ir::RustIr;
 use rustc_type_ir::solve::AdtDestructorKind;
 use tracing::{debug, info, trace};
 
@@ -220,7 +219,7 @@ impl<'tcx> rustc_type_ir::inherent::AdtDef<TyCtxt<'tcx>> for AdtDef<'tcx> {
 
 impl<'tcx> rustc_type_ir::inherent::IrAdtDef<TyCtxt<'tcx>, TyCtxt<'tcx>> for AdtDef<'tcx> {
     fn struct_tail_ty(self, cx: TyCtxt<'tcx>) -> Option<ty::EarlyBinder<'tcx, Ty<'tcx>>> {
-        Some(cx.interner().type_of(self.non_enum_variant().tail_opt()?.did))
+        Some(cx.type_of(self.non_enum_variant().tail_opt()?.did))
     }
 
     fn all_field_tys(

Diff for: compiler/rustc_middle/src/ty/context.rs

@@ -120,9 +120,7 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
         self.mk_external_constraints(data)
     }
     type DepNodeIndex = DepNodeIndex;
-    fn with_cached_task<T>(self, task: impl FnOnce() -> T) -> (T, DepNodeIndex) {
-        self.dep_graph.with_anon_task(self, crate::dep_graph::dep_kinds::TraitSelect, task)
-    }
+
     type Ty = Ty<'tcx>;
     type Tys = &'tcx List<Ty<'tcx>>;
 
@@ -158,15 +156,53 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
     type Clause = Clause<'tcx>;
     type Clauses = ty::Clauses<'tcx>;
 
+    type Features = &'tcx rustc_feature::Features;
+
     type Tracked<T: fmt::Debug + Clone> = WithDepNode<T>;
+
+    type GenericsOf = &'tcx ty::Generics;
+
+    type VariancesOf = &'tcx [ty::Variance];
+
+    type AdtDef = ty::AdtDef<'tcx>;
+
+    type UnsizingParams = &'tcx rustc_index::bit_set::BitSet<u32>;
+
+    fn mk_args(self, args: &[Self::GenericArg]) -> ty::GenericArgsRef<'tcx> {
+        self.mk_args(args)
+    }
+
+    fn mk_args_from_iter<I, T>(self, args: I) -> T::Output
+    where
+        I: Iterator<Item = T>,
+        T: CollectAndApply<Self::GenericArg, ty::GenericArgsRef<'tcx>>,
+    {
+        self.mk_args_from_iter(args)
+    }
+}
+
+impl<'tcx> RustIr for TyCtxt<'tcx> {
+    type Interner = Self;
+
+    fn interner(self) -> Self::Interner {
+        self
+    }
+
+    fn with_cached_task<T>(self, task: impl FnOnce() -> T) -> (T, DepNodeIndex) {
+        self.dep_graph.with_anon_task(self, crate::dep_graph::dep_kinds::TraitSelect, task)
+    }
+
     fn mk_tracked<T: fmt::Debug + Clone>(
         self,
         data: T,
         dep_node: DepNodeIndex,
-    ) -> Self::Tracked<T> {
+    ) -> <Self::Interner as Interner>::Tracked<T> {
         WithDepNode::new(dep_node, data)
     }
-    fn get_tracked<T: fmt::Debug + Clone>(self, tracked: &Self::Tracked<T>) -> T {
+    fn get_tracked<T: fmt::Debug + Clone>(
+        self,
+        tracked: &<Self::Interner as Interner>::Tracked<T>,
+    ) -> T {
         tracked.get(self)
     }
 
@@ -182,24 +218,19 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
         self.expand_abstract_consts(t)
     }
 
-    type GenericsOf = &'tcx ty::Generics;
-
     fn generics_of(self, def_id: DefId) -> &'tcx ty::Generics {
         self.generics_of(def_id)
     }
 
-    type VariancesOf = &'tcx [ty::Variance];
-
-    fn variances_of(self, def_id: DefId) -> Self::VariancesOf {
+    fn variances_of(self, def_id: DefId) -> <Self::Interner as Interner>::VariancesOf {
         self.variances_of(def_id)
     }
 
     fn type_of(self, def_id: DefId) -> ty::EarlyBinder<'tcx, Ty<'tcx>> {
         self.type_of(def_id)
     }
 
-    type AdtDef = ty::AdtDef<'tcx>;
-    fn adt_def(self, adt_def_id: DefId) -> Self::AdtDef {
+    fn adt_def(self, adt_def_id: DefId) -> <Self::Interner as Interner>::AdtDef {
         self.adt_def(adt_def_id)
     }
 
@@ -254,18 +285,6 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
         )
     }
 
-    fn mk_args(self, args: &[Self::GenericArg]) -> ty::GenericArgsRef<'tcx> {
-        self.mk_args(args)
-    }
-
-    fn mk_args_from_iter<I, T>(self, args: I) -> T::Output
-    where
-        I: Iterator<Item = T>,
-        T: CollectAndApply<Self::GenericArg, ty::GenericArgsRef<'tcx>>,
-    {
-        self.mk_args_from_iter(args)
-    }
-
     fn check_args_compatible(self, def_id: DefId, args: ty::GenericArgsRef<'tcx>) -> bool {
         self.check_args_compatible(def_id, args)
     }
@@ -279,8 +298,8 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
     /// a dummy self type and forward to `debug_assert_args_compatible`.
     fn debug_assert_existential_args_compatible(
         self,
-        def_id: Self::DefId,
-        args: Self::GenericArgs,
+        def_id: <Self::Interner as Interner>::DefId,
+        args: <Self::Interner as Interner>::GenericArgs,
     ) {
         // FIXME: We could perhaps add a `skip: usize` to `debug_assert_args_compatible`
         // to avoid needing to reintern the set of args...
@@ -310,9 +329,7 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
         self.recursion_limit().0
     }
 
-    type Features = &'tcx rustc_feature::Features;
-
-    fn features(self) -> Self::Features {
+    fn features(self) -> <Self::Interner as Interner>::Features {
         self.features()
     }
 
@@ -611,15 +628,17 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
         self.coroutine_is_async_gen(coroutine_def_id)
     }
 
-    type UnsizingParams = &'tcx rustc_index::bit_set::BitSet<u32>;
-    fn unsizing_params_for_adt(self, adt_def_id: DefId) -> Self::UnsizingParams {
+    fn unsizing_params_for_adt(
+        self,
+        adt_def_id: DefId,
+    ) -> <Self::Interner as Interner>::UnsizingParams {
         self.unsizing_params_for_adt(adt_def_id)
     }
 
     fn find_const_ty_from_env(
         self,
         param_env: &ty::ParamEnv<'tcx>,
-        placeholder: Self::PlaceholderConst,
+        placeholder: <Self::Interner as Interner>::PlaceholderConst,
     ) -> Ty<'tcx> {
         placeholder.find_const_ty_from_env(param_env)
     }
@@ -631,19 +650,14 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
         self.anonymize_bound_vars(binder)
     }
 
-    fn opaque_types_defined_by(self, defining_anchor: LocalDefId) -> Self::DefiningOpaqueTypes {
+    fn opaque_types_defined_by(
+        self,
+        defining_anchor: LocalDefId,
+    ) -> <Self::Interner as Interner>::DefiningOpaqueTypes {
         self.opaque_types_defined_by(defining_anchor)
     }
 }
 
-impl<'tcx> RustIr for TyCtxt<'tcx> {
-    type Interner = Self;
-
-    fn interner(self) -> Self::Interner {
-        self
-    }
-}
-
 macro_rules! bidirectional_lang_item_map {
     ($($name:ident),+ $(,)?) => {
         fn trait_lang_item_to_lang_item(lang_item: TraitSolverLangItem) -> LangItem {

Diff for: compiler/rustc_middle/src/ty/generic_args.rs

@@ -47,15 +47,6 @@ impl<'tcx> rustc_type_ir::inherent::GenericArgs<TyCtxt<'tcx>> for ty::GenericArg
         Default::default()
     }
 
-    fn rebase_onto(
-        self,
-        tcx: TyCtxt<'tcx>,
-        source_ancestor: DefId,
-        target_args: GenericArgsRef<'tcx>,
-    ) -> GenericArgsRef<'tcx> {
-        self.rebase_onto(tcx, source_ancestor, target_args)
-    }
-
     fn type_at(self, i: usize) -> Ty<'tcx> {
         self.type_at(i)
     }
@@ -68,18 +59,6 @@ impl<'tcx> rustc_type_ir::inherent::GenericArgs<TyCtxt<'tcx>> for ty::GenericArg
         self.const_at(i)
     }
 
-    fn identity_for_item(tcx: TyCtxt<'tcx>, def_id: DefId) -> ty::GenericArgsRef<'tcx> {
-        GenericArgs::identity_for_item(tcx, def_id)
-    }
-
-    fn extend_with_error(
-        tcx: TyCtxt<'tcx>,
-        def_id: DefId,
-        original_args: &[ty::GenericArg<'tcx>],
-    ) -> ty::GenericArgsRef<'tcx> {
-        ty::GenericArgs::extend_with_error(tcx, def_id, original_args)
-    }
-
     fn split_closure_args(self) -> ty::ClosureArgsParts<TyCtxt<'tcx>> {
         match self[..] {
             [ref parent_args @ .., closure_kind_ty, closure_sig_as_fn_ptr_ty, tupled_upvars_ty] => {
@@ -139,6 +118,31 @@ impl<'tcx> rustc_type_ir::inherent::GenericArgs<TyCtxt<'tcx>> for ty::GenericArg
     }
 }
 
+impl<'tcx> rustc_type_ir::inherent::IrGenericArgs<TyCtxt<'tcx>, TyCtxt<'tcx>>
+    for ty::GenericArgsRef<'tcx>
+{
+    fn rebase_onto(
+        self,
+        tcx: TyCtxt<'tcx>,
+        source_ancestor: DefId,
+        target_args: GenericArgsRef<'tcx>,
+    ) -> GenericArgsRef<'tcx> {
+        self.rebase_onto(tcx, source_ancestor, target_args)
+    }
+
+    fn identity_for_item(tcx: TyCtxt<'tcx>, def_id: DefId) -> ty::GenericArgsRef<'tcx> {
+        GenericArgs::identity_for_item(tcx, def_id)
+    }
+
+    fn extend_with_error(
+        tcx: TyCtxt<'tcx>,
+        def_id: DefId,
+        original_args: &[ty::GenericArg<'tcx>],
+    ) -> ty::GenericArgsRef<'tcx> {
+        ty::GenericArgs::extend_with_error(tcx, def_id, original_args)
+    }
+}
+
 impl<'tcx> rustc_type_ir::inherent::IntoKind for GenericArg<'tcx> {
     type Kind = GenericArgKind<'tcx>;
 

Diff for: compiler/rustc_next_trait_solver/src/coherence.rs

@@ -60,7 +60,7 @@ where
         return Ok(Err(Conflict::Downstream));
     }
 
-    if trait_ref_is_local_or_fundamental(infcx.cx().interner(), trait_ref.clone()) {
+    if trait_ref_is_local_or_fundamental(infcx.cx(), trait_ref.clone()) {
         // This is a local or fundamental trait, so future-compatibility
         // is no concern. We know that downstream/cousin crates are not
         // allowed to implement a generic parameter of this trait ref,
@@ -91,7 +91,10 @@ where
     }
 }
 
-pub fn trait_ref_is_local_or_fundamental<I: Interner>(tcx: I, trait_ref: ty::TraitRef<I>) -> bool {
+pub fn trait_ref_is_local_or_fundamental<Ir: RustIr<Interner = I>, I: Interner>(
+    tcx: Ir,
+    trait_ref: ty::TraitRef<I>,
+) -> bool {
     trait_ref.def_id.is_local() || tcx.trait_is_fundamental(trait_ref.def_id)
 }
 

Diff for: compiler/rustc_next_trait_solver/src/delegate.rs

@@ -15,7 +15,7 @@ pub trait SolverDelegate: Deref<Target = <Self as SolverDelegate>::Infcx> + Size
     type Span: Copy;
 
     fn build_with_canonical<V>(
-        cx: Self::Interner,
+        cx: Self::Ir,
         canonical: &ty::CanonicalQueryInput<Self::Interner, V>,
     ) -> (Self, V, ty::CanonicalVarValues<Self::Interner>)
     where

Diff for: compiler/rustc_next_trait_solver/src/solve/alias_relate.rs

@@ -27,6 +27,7 @@ where
     D: SolverDelegate<Interner = I>,
     I: Interner,
     <I as Interner>::AdtDef: IrAdtDef<I, D::Ir>,
+    <I as Interner>::GenericArgs: IrGenericArgs<I, D::Ir>,
 {
     #[instrument(level = "trace", skip(self), ret)]
     pub(super) fn compute_alias_relate_goal(