Fix canonicalizing different infer kinds

Author: compiler-errors

compiler/rustc_infer/src/infer/mod.rs

@@ -349,19 +349,10 @@ impl<'tcx> ty::InferCtxtLike for InferCtxt<'tcx> {
         self.tcx
     }
 
-    fn universe_of_ty(&self, ty: ty::InferTy) -> Option<ty::UniverseIndex> {
-        use InferTy::*;
-        match ty {
-            // FIXME(BoxyUwU): this is kind of jank and means that printing unresolved
-            // ty infers will give you the universe of the var it resolved to not the universe
-            // it actually had. It also means that if you have a `?0.1` and infer it to `u8` then
-            // try to print out `?0.1` it will just print `?0`.
-            TyVar(ty_vid) => match self.probe_ty_var(ty_vid) {
-                Err(universe) => Some(universe),
-                Ok(_) => None,
-            },
-            IntVar(_) | FloatVar(_) => Some(ty::UniverseIndex::ROOT),
-            FreshTy(_) | FreshIntTy(_) | FreshFloatTy(_) => None,
+    fn universe_of_ty(&self, vid: TyVid) -> Option<ty::UniverseIndex> {
+        match self.probe_ty_var(vid) {
+            Err(universe) => Some(universe),
+            Ok(_) => None,
         }
     }
 

compiler/rustc_middle/src/ty/context.rs

@@ -26,9 +26,9 @@ use crate::traits::solve::{
 };
 use crate::ty::{
     self, AdtDef, AdtDefData, AdtKind, Binder, Clause, Const, ConstData, GenericParamDefKind,
-    ImplPolarity, InferTy, List, ParamConst, ParamTy, PolyExistentialPredicate, PolyFnSig,
-    Predicate, PredicateKind, Region, RegionKind, ReprOptions, TraitObjectVisitor, Ty, TyKind,
-    TyVid, TypeAndMut, Visibility,
+    ImplPolarity, List, ParamConst, ParamTy, PolyExistentialPredicate, PolyFnSig, Predicate,
+    PredicateKind, Region, RegionKind, ReprOptions, TraitObjectVisitor, Ty, TyKind, TyVid,
+    TypeAndMut, Visibility,
 };
 use crate::ty::{GenericArg, GenericArgs, GenericArgsRef};
 use rustc_ast::{self as ast, attr};
@@ -96,7 +96,6 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
     type ParamTy = ParamTy;
     type BoundTy = ty::BoundTy;
     type PlaceholderTy = ty::PlaceholderType;
-    type InferTy = InferTy;
 
     type ErrorGuaranteed = ErrorGuaranteed;
     type BoundExistentialPredicates = &'tcx List<PolyExistentialPredicate<'tcx>>;

compiler/rustc_type_ir/src/canonicalizer.rs

@@ -1,9 +1,10 @@
 use std::cmp::Ordering;
 
+use crate::canonical::*;
 use crate::fold::{TypeFoldable, TypeFolder, TypeSuperFoldable};
-use crate::{canonical::*, ConstTy, IntoKind, Placeholder};
 use crate::{
-    BoundVar, ConstKind, DebruijnIndex, InferCtxtLike, Interner, RegionKind, TyKind, UniverseIndex,
+    BoundVar, ConstKind, ConstTy, DebruijnIndex, InferCtxtLike, InferTy, Interner, IntoKind,
+    Placeholder, RegionKind, TyKind, UniverseIndex,
 };
 
 /// Whether we're canonicalizing a query input or the query response.
@@ -288,9 +289,16 @@ impl<Infcx: InferCtxtLike<Interner = I>, I: Interner> TypeFolder<I> for Canonica
                 let Err(ui) = self.infcx.probe_ty_var(vid) else {
                     panic!("ty var should have been resolved: {t}");
                 }; */
-                CanonicalVarKind::Ty(CanonicalTyVarKind::General(
-                    self.infcx.universe_of_ty(i).unwrap(),
-                ))
+                match i {
+                    InferTy::TyVar(vid) => CanonicalVarKind::Ty(CanonicalTyVarKind::General(
+                        self.infcx.universe_of_ty(vid).unwrap(),
+                    )),
+                    InferTy::IntVar(_) => CanonicalVarKind::Ty(CanonicalTyVarKind::Int),
+                    InferTy::FloatVar(_) => CanonicalVarKind::Ty(CanonicalTyVarKind::Float),
+                    InferTy::FreshTy(_) | InferTy::FreshIntTy(_) | InferTy::FreshFloatTy(_) => {
+                        todo!()
+                    }
+                }
             }
             TyKind::Placeholder(placeholder) => match self.canonicalize_mode {
                 CanonicalizeMode::Input => CanonicalVarKind::PlaceholderTy(Placeholder::new(
@@ -348,6 +356,7 @@ impl<Infcx: InferCtxtLike<Interner = I>, I: Interner> TypeFolder<I> for Canonica
         I::Const: TypeSuperFoldable<I>,
     {
         let kind = match c.kind() {
+            // TODO: This will not canonicalize effect vars until InferConst is uplifted.
             ConstKind::Infer(i) => {
                 /* TODO: assert_eq!(
                     self.infcx.root_const_var(vid),

compiler/rustc_type_ir/src/debug.rs

@@ -1,4 +1,4 @@
-use crate::{InferCtxtLike, Interner, UniverseIndex};
+use crate::{InferCtxtLike, Interner, TyVid, UniverseIndex};
 
 use core::fmt;
 use std::marker::PhantomData;
@@ -8,7 +8,7 @@ pub struct NoInfcx<I>(PhantomData<I>);
 impl<I: Interner> InferCtxtLike for NoInfcx<I> {
     type Interner = I;
 
-    fn universe_of_ty(&self, _ty: <I as Interner>::InferTy) -> Option<UniverseIndex> {
+    fn universe_of_ty(&self, _ty: TyVid) -> Option<UniverseIndex> {
         None
     }
 

compiler/rustc_type_ir/src/infcx.rs

@@ -1,11 +1,11 @@
-use crate::{Interner, UniverseIndex};
+use crate::{Interner, TyVid, UniverseIndex};
 
 pub trait InferCtxtLike {
     type Interner: Interner;
 
     fn interner(&self) -> Self::Interner;
 
-    fn universe_of_ty(&self, ty: <Self::Interner as Interner>::InferTy) -> Option<UniverseIndex>;
+    fn universe_of_ty(&self, ty: TyVid) -> Option<UniverseIndex>;
 
     fn universe_of_lt(
         &self,

compiler/rustc_type_ir/src/interner.rs

@@ -36,7 +36,6 @@ pub trait Interner: Sized {
     type ParamTy: Clone + Debug + Hash + Ord;
     type BoundTy: Clone + Debug + Hash + Ord;
     type PlaceholderTy: Clone + Debug + Hash + Ord + Placeholder<Self>;
-    type InferTy: Clone + DebugWithInfcx<Self> + Hash + Ord;
 
     // Things stored inside of tys
     type ErrorGuaranteed: Clone + Debug + Hash + Ord;

compiler/rustc_type_ir/src/ty_kind.rs

@@ -280,7 +280,7 @@ pub enum TyKind<I: Interner> {
     /// correctly deal with higher ranked types. Though unlike placeholders,
     /// that universe is stored in the `InferCtxt` instead of directly
     /// inside of the type.
-    Infer(I::InferTy),
+    Infer(InferTy),
 
     /// A placeholder for a type which could not be computed; this is
     /// propagated to avoid useless error messages.
@@ -797,20 +797,20 @@ impl fmt::Debug for InferTy {
     }
 }
 
-impl<I: Interner<InferTy = InferTy>> DebugWithInfcx<I> for InferTy {
+impl<I: Interner> DebugWithInfcx<I> for InferTy {
     fn fmt<Infcx: InferCtxtLike<Interner = I>>(
         this: WithInfcx<'_, Infcx, &Self>,
         f: &mut fmt::Formatter<'_>,
     ) -> fmt::Result {
-        use InferTy::*;
-        match this.infcx.universe_of_ty(*this.data) {
-            None => write!(f, "{:?}", this.data),
-            Some(universe) => match *this.data {
-                TyVar(ty_vid) => write!(f, "?{}_{}t", ty_vid.index(), universe.index()),
-                IntVar(_) | FloatVar(_) | FreshTy(_) | FreshIntTy(_) | FreshFloatTy(_) => {
-                    unreachable!()
+        match this.data {
+            InferTy::TyVar(vid) => {
+                if let Some(universe) = this.infcx.universe_of_ty(*vid) {
+                    write!(f, "?{}_{}t", vid.index(), universe.index())
+                } else {
+                    write!(f, "{:?}", this.data)
                 }
-            },
+            }
+            _ => write!(f, "{:?}", this.data),
         }
     }
 }