Removing use crate::inherent::Ty as _; and adding ty::Ty<I>

Author: Jamesbarford

compiler/rustc_next_trait_solver/src/canonical/canonicalizer.rs

@@ -1,11 +1,9 @@
 use rustc_type_ir::data_structures::{HashMap, ensure_sufficient_stack};
-#[cfg_attr(feature = "nightly", allow(rustc::non_glob_import_of_type_ir_inherent))]
-use rustc_type_ir::inherent::Ty as _;
 use rustc_type_ir::inherent::*;
 use rustc_type_ir::solve::{Goal, QueryInput};
 use rustc_type_ir::{
     self as ty, Canonical, CanonicalParamEnvCacheEntry, CanonicalVarKind, Flags, InferCtxtLike,
-    Interner, PlaceholderConst, PlaceholderType, Ty, TypeFlags, TypeFoldable, TypeFolder,
+    Interner, PlaceholderConst, PlaceholderType, TypeFlags, TypeFoldable, TypeFolder,
     TypeSuperFoldable, TypeVisitableExt,
 };
 
@@ -80,7 +78,7 @@ pub(super) struct Canonicalizer<'a, D: SolverDelegate<Interner = I>, I: Interner
 
     /// We can simply cache based on the ty itself, because we use
     /// `ty::BoundVarIndexKind::Canonical`.
-    cache: HashMap<Ty<I>, Ty<I>>,
+    cache: HashMap<ty::Ty<I>, ty::Ty<I>>,
 }
 
 impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
@@ -318,7 +316,7 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
         (max_universe, self.variables, var_kinds)
     }
 
-    fn inner_fold_ty(&mut self, t: Ty<I>) -> Ty<I> {
+    fn inner_fold_ty(&mut self, t: ty::Ty<I>) -> ty::Ty<I> {
         let kind = match t.kind() {
             ty::Infer(i) => match i {
                 ty::TyVar(vid) => {
@@ -402,7 +400,7 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
 
         let var = self.get_or_insert_bound_var(t, kind);
 
-        I::Ty::new_canonical_bound(self.cx(), var)
+        Ty::new_canonical_bound(self.cx(), var)
     }
 }
 
@@ -477,7 +475,7 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I> for Canonicaliz
         Region::new_canonical_bound(self.cx(), var)
     }
 
-    fn fold_ty(&mut self, t: Ty<I>) -> Ty<I> {
+    fn fold_ty(&mut self, t: ty::Ty<I>) -> ty::Ty<I> {
         if !t.flags().intersects(NEEDS_CANONICAL) {
             t
         } else if let Some(&ty) = self.cache.get(&t) {

compiler/rustc_next_trait_solver/src/coherence.rs

@@ -2,11 +2,9 @@ use std::fmt::Debug;
 use std::ops::ControlFlow;
 
 use derive_where::derive_where;
-#[cfg_attr(feature = "nightly", allow(rustc::non_glob_import_of_type_ir_inherent))]
-use rustc_type_ir::inherent::Ty as _;
 use rustc_type_ir::inherent::*;
 use rustc_type_ir::{
-    self as ty, InferCtxtLike, Interner, TrivialTypeTraversalImpls, Ty, TypeVisitable,
+    self as ty, InferCtxtLike, Interner, TrivialTypeTraversalImpls, TypeVisitable,
     TypeVisitableExt, TypeVisitor,
 };
 use tracing::instrument;
@@ -49,7 +47,7 @@ pub enum Conflict {
 pub fn trait_ref_is_knowable<Infcx, I, E>(
     infcx: &Infcx,
     trait_ref: ty::TraitRef<I>,
-    mut lazily_normalize_ty: impl FnMut(Ty<I>) -> Result<Ty<I>, E>,
+    mut lazily_normalize_ty: impl FnMut(ty::Ty<I>) -> Result<ty::Ty<I>, E>,
 ) -> Result<Result<(), Conflict>, E>
 where
     Infcx: InferCtxtLike<Interner = I>,
@@ -117,14 +115,14 @@ impl From<bool> for IsFirstInputType {
 
 #[derive_where(Debug; I: Interner, T: Debug)]
 pub enum OrphanCheckErr<I: Interner, T> {
-    NonLocalInputType(Vec<(Ty<I>, IsFirstInputType)>),
+    NonLocalInputType(Vec<(ty::Ty<I>, IsFirstInputType)>),
     UncoveredTyParams(UncoveredTyParams<I, T>),
 }
 
 #[derive_where(Debug; I: Interner, T: Debug)]
 pub struct UncoveredTyParams<I: Interner, T> {
     pub uncovered: T,
-    pub local_ty: Option<Ty<I>>,
+    pub local_ty: Option<ty::Ty<I>>,
 }
 
 /// Checks whether a trait-ref is potentially implementable by a crate.
@@ -224,8 +222,8 @@ pub fn orphan_check_trait_ref<Infcx, I, E: Debug>(
     infcx: &Infcx,
     trait_ref: ty::TraitRef<I>,
     in_crate: InCrate,
-    lazily_normalize_ty: impl FnMut(Ty<I>) -> Result<Ty<I>, E>,
-) -> Result<Result<(), OrphanCheckErr<I, Ty<I>>>, E>
+    lazily_normalize_ty: impl FnMut(ty::Ty<I>) -> Result<ty::Ty<I>, E>,
+) -> Result<Result<(), OrphanCheckErr<I, ty::Ty<I>>>, E>
 where
     Infcx: InferCtxtLike<Interner = I>,
     I: Interner,
@@ -264,14 +262,14 @@ struct OrphanChecker<'a, Infcx, I: Interner, F> {
     lazily_normalize_ty: F,
     /// Ignore orphan check failures and exclusively search for the first local type.
     search_first_local_ty: bool,
-    non_local_tys: Vec<(Ty<I>, IsFirstInputType)>,
+    non_local_tys: Vec<(ty::Ty<I>, IsFirstInputType)>,
 }
 
 impl<'a, Infcx, I, F, E> OrphanChecker<'a, Infcx, I, F>
 where
     Infcx: InferCtxtLike<Interner = I>,
     I: Interner,
-    F: FnOnce(Ty<I>) -> Result<Ty<I>, E>,
+    F: FnOnce(ty::Ty<I>) -> Result<ty::Ty<I>, E>,
 {
     fn new(infcx: &'a Infcx, in_crate: InCrate, lazily_normalize_ty: F) -> Self {
         OrphanChecker {
@@ -284,12 +282,15 @@ where
         }
     }
 
-    fn found_non_local_ty(&mut self, t: Ty<I>) -> ControlFlow<OrphanCheckEarlyExit<I, E>> {
+    fn found_non_local_ty(&mut self, t: ty::Ty<I>) -> ControlFlow<OrphanCheckEarlyExit<I, E>> {
         self.non_local_tys.push((t, self.in_self_ty.into()));
         ControlFlow::Continue(())
     }
 
-    fn found_uncovered_ty_param(&mut self, ty: Ty<I>) -> ControlFlow<OrphanCheckEarlyExit<I, E>> {
+    fn found_uncovered_ty_param(
+        &mut self,
+        ty: ty::Ty<I>,
+    ) -> ControlFlow<OrphanCheckEarlyExit<I, E>> {
         if self.search_first_local_ty {
             return ControlFlow::Continue(());
         }
@@ -307,23 +308,23 @@ where
 
 enum OrphanCheckEarlyExit<I: Interner, E> {
     NormalizationFailure(E),
-    UncoveredTyParam(Ty<I>),
-    LocalTy(Ty<I>),
+    UncoveredTyParam(ty::Ty<I>),
+    LocalTy(ty::Ty<I>),
 }
 
 impl<'a, Infcx, I, F, E> TypeVisitor<I> for OrphanChecker<'a, Infcx, I, F>
 where
     Infcx: InferCtxtLike<Interner = I>,
     I: Interner,
-    F: FnMut(Ty<I>) -> Result<Ty<I>, E>,
+    F: FnMut(ty::Ty<I>) -> Result<ty::Ty<I>, E>,
 {
     type Result = ControlFlow<OrphanCheckEarlyExit<I, E>>;
 
     fn visit_region(&mut self, _r: I::Region) -> Self::Result {
         ControlFlow::Continue(())
     }
 
-    fn visit_ty(&mut self, ty: Ty<I>) -> Self::Result {
+    fn visit_ty(&mut self, ty: ty::Ty<I>) -> Self::Result {
         let ty = self.infcx.shallow_resolve(ty);
         let ty = match (self.lazily_normalize_ty)(ty) {
             Ok(norm_ty) if norm_ty.is_ty_var() => ty,

compiler/rustc_next_trait_solver/src/placeholder.rs

@@ -1,11 +1,9 @@
 use core::panic;
 
 use rustc_type_ir::data_structures::IndexMap;
-#[cfg_attr(feature = "nightly", allow(rustc::non_glob_import_of_type_ir_inherent))]
-use rustc_type_ir::inherent::Ty as _;
 use rustc_type_ir::inherent::*;
 use rustc_type_ir::{
-    self as ty, InferCtxtLike, Interner, PlaceholderConst, PlaceholderRegion, PlaceholderType, Ty,
+    self as ty, InferCtxtLike, Interner, PlaceholderConst, PlaceholderRegion, PlaceholderType,
     TypeFoldable, TypeFolder, TypeSuperFoldable, TypeVisitableExt,
 };
 
@@ -115,7 +113,7 @@ where
         }
     }
 
-    fn fold_ty(&mut self, t: Ty<I>) -> Ty<I> {
+    fn fold_ty(&mut self, t: ty::Ty<I>) -> ty::Ty<I> {
         match t.kind() {
             ty::Bound(ty::BoundVarIndexKind::Bound(debruijn), _)
                 if debruijn.as_usize() + 1
@@ -132,7 +130,7 @@ where
                 let universe = self.universe_for(debruijn);
                 let p = PlaceholderType::new(universe, bound_ty);
                 self.mapped_types.insert(p, bound_ty);
-                I::Ty::new_placeholder(self.cx(), p)
+                Ty::new_placeholder(self.cx(), p)
             }
             _ if t.has_vars_bound_at_or_above(self.current_index) => t.super_fold_with(self),
             _ => t,

compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs

@@ -6,15 +6,13 @@ use std::cell::Cell;
 use std::ops::ControlFlow;
 
 use derive_where::derive_where;
-#[cfg_attr(feature = "nightly", allow(rustc::non_glob_import_of_type_ir_inherent))]
-use rustc_type_ir::inherent::Ty as _;
 use rustc_type_ir::inherent::*;
 use rustc_type_ir::lang_items::SolverTraitLangItem;
 use rustc_type_ir::search_graph::CandidateHeadUsages;
 use rustc_type_ir::solve::Certainty::Maybe;
 use rustc_type_ir::solve::{AliasBoundKind, SizedTraitKind};
 use rustc_type_ir::{
-    self as ty, Interner, Ty, TypeFlags, TypeFoldable, TypeFolder, TypeSuperFoldable,
+    self as ty, Interner, TypeFlags, TypeFoldable, TypeFolder, TypeSuperFoldable,
     TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor, TypingMode, Upcast,
     elaborate,
 };
@@ -48,11 +46,11 @@ where
     D: SolverDelegate<Interner = I>,
     I: Interner,
 {
-    fn self_ty(self) -> Ty<I>;
+    fn self_ty(self) -> ty::Ty<I>;
 
     fn trait_ref(self, cx: I) -> ty::TraitRef<I>;
 
-    fn with_replaced_self_ty(self, cx: I, self_ty: Ty<I>) -> Self;
+    fn with_replaced_self_ty(self, cx: I, self_ty: ty::Ty<I>) -> Self;
 
     fn trait_def_id(self, cx: I) -> I::TraitId;
 
@@ -685,7 +683,7 @@ where
     // hitting another overflow error something. Add a depth parameter needed later.
     fn assemble_alias_bound_candidates_recur<G: GoalKind<D>>(
         &mut self,
-        self_ty: Ty<I>,
+        self_ty: ty::Ty<I>,
         goal: Goal<I, G>,
         candidates: &mut Vec<Candidate<I>>,
         consider_self_bounds: AliasBoundKind,
@@ -1019,13 +1017,13 @@ where
             struct ReplaceOpaque<I: Interner> {
                 cx: I,
                 alias_ty: ty::AliasTy<I>,
-                self_ty: Ty<I>,
+                self_ty: ty::Ty<I>,
             }
             impl<I: Interner> TypeFolder<I> for ReplaceOpaque<I> {
                 fn cx(&self) -> I {
                     self.cx
                 }
-                fn fold_ty(&mut self, ty: Ty<I>) -> Ty<I> {
+                fn fold_ty(&mut self, ty: ty::Ty<I>) -> ty::Ty<I> {
                     if let ty::Alias(ty::Opaque, alias_ty) = ty.kind() {
                         if alias_ty == self.alias_ty {
                             return self.self_ty;
@@ -1282,7 +1280,7 @@ where
         ControlFlow::Continue(())
     }
 
-    fn visit_ty(&mut self, ty: Ty<I>) -> Self::Result {
+    fn visit_ty(&mut self, ty: ty::Ty<I>) -> Self::Result {
         let ty = self.ecx.replace_bound_vars(ty, &mut self.universes);
         let Ok(ty) = self.ecx.structurally_normalize_ty(self.param_env, ty) else {
             return ControlFlow::Break(Err(NoSolution));