Move TermVid to rustc_type_ir

Author: khyperia

compiler/rustc_infer/src/infer/relate/generalize.rs

@@ -6,8 +6,8 @@ use rustc_hir::def_id::DefId;
 use rustc_middle::bug;
 use rustc_middle::ty::error::TypeError;
 use rustc_middle::ty::{
-    self, AliasRelationDirection, InferConst, Term, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable,
-    TypeVisitableExt, TypeVisitor, TypingMode,
+    self, AliasRelationDirection, InferConst, Term, TermVid, Ty, TyCtxt, TypeSuperVisitable,
+    TypeVisitable, TypeVisitableExt, TypeVisitor, TypingMode,
 };
 use rustc_span::Span;
 use tracing::{debug, instrument, warn};
@@ -19,31 +19,6 @@ use crate::infer::type_variable::TypeVariableValue;
 use crate::infer::unify_key::ConstVariableValue;
 use crate::infer::{InferCtxt, RegionVariableOrigin, relate};
 
-#[derive(Copy, Clone, Eq, PartialEq, Debug)]
-enum TermVid {
-    Ty(ty::TyVid),
-    Const(ty::ConstVid),
-}
-
-impl From<ty::TyVid> for TermVid {
-    fn from(value: ty::TyVid) -> Self {
-        TermVid::Ty(value)
-    }
-}
-
-impl From<ty::ConstVid> for TermVid {
-    fn from(value: ty::ConstVid) -> Self {
-        TermVid::Const(value)
-    }
-}
-
-fn term_vid<'tcx>(term: Term<'tcx>) -> Option<TermVid> {
-    match term.kind() {
-        rustc_type_ir::TermKind::Ty(ty) => ty.ty_vid().map(TermVid::Ty),
-        rustc_type_ir::TermKind::Const(ct) => ct.ct_vid().map(TermVid::Const),
-    }
-}
-
 impl<'tcx> InferCtxt<'tcx> {
     /// The idea is that we should ensure that the type variable `target_vid`
     /// is equal to, a subtype of, or a supertype of `source_ty`.
@@ -153,7 +128,7 @@ impl<'tcx> InferCtxt<'tcx> {
         {
             let normalized_alias = relation.try_eagerly_normalize_alias(alias);
 
-            if term_vid(normalized_alias).is_some() {
+            if normalized_alias.is_infer() {
                 normalized_alias
             } else {
                 let Generalization { value_may_be_infer: generalized_term } = self.generalize(
@@ -169,19 +144,19 @@ impl<'tcx> InferCtxt<'tcx> {
                 // However, here, though we know it *is* an alias, we initialize the generalizer
                 // with `ShallowStructurallyRelateAliases` so we treat the outermost alias as rigid,
                 // ensuring this is never a tyvar.
-                assert!(term_vid(generalized_term).is_none());
+                assert!(!generalized_term.is_infer());
 
                 generalized_term
             }
         } else {
-            // Generalize `source_ty` depending on the current variance. As an example, assume
+            // Generalize `source_term` depending on the current variance. As an example, assume
             // `?target <: &'x ?1`, where `'x` is some free region and `?1` is an inference
             // variable.
             //
-            // Then the `generalized_ty` would be `&'?2 ?3`, where `'?2` and `?3` are fresh
+            // Then the `generalized_term` would be `&'?2 ?3`, where `'?2` and `?3` are fresh
             // region/type inference variables.
             //
-            // We then relate `generalized_ty <: source_ty`, adding constraints like `'x: '?2` and
+            // We then relate `generalized_term <: source_term`, adding constraints like `'x: '?2` and
             // `?1 <: ?3`.
             let Generalization { value_may_be_infer: generalized_term } = self.generalize(
                 relation.span(),
@@ -198,15 +173,15 @@ impl<'tcx> InferCtxt<'tcx> {
             generalized_term
         };
 
-        // Finally, relate `generalized_ty` to `source_ty`, as described in previous comment.
+        // Finally, relate `generalized_term` to `source_term`, as described in previous comment.
         //
         // FIXME(#16847): This code is non-ideal because all these subtype
         // relations wind up attributed to the same spans. We need
         // to associate causes/spans with each of the relations in
         // the stack to get this right.
-        if let Some(generalized_vid) = term_vid(generalized_term) {
+        if let Some(generalized_vid) = generalized_term.term_vid() {
             // Constrain `b_vid` to the generalized type variable.
-            self.equate(target_vid, generalized_vid);
+            self.union_vars(target_vid, generalized_vid);
 
             // This happens for cases like `<?0 as Trait>::Assoc == ?0`.
             // We can't instantiate `?0` here as that would result in a
@@ -229,39 +204,41 @@ impl<'tcx> InferCtxt<'tcx> {
 
                 relation.register_predicates([ty::PredicateKind::AliasRelate(lhs, rhs, direction)]);
             } else {
-                match source_term.kind() {
-                    ty::TermKind::Ty(source_ty) => {
-                        match source_ty.kind() {
-                            &ty::Alias(ty::Projection, data) => {
-                                // FIXME: This does not handle subtyping correctly, we could instead
-                                // create a new inference variable `?normalized_source`, emitting
-                                // `Projection(normalized_source, ?ty_normalized)` and
-                                // `?normalized_source <: generalized_ty`.
-                                relation.register_predicates([ty::ProjectionPredicate {
-                                    projection_term: data.into(),
-                                    term: generalized_term,
-                                }]);
-                            }
-                            // The old solver only accepts projection predicates for associated types.
-                            ty::Alias(ty::Inherent | ty::Free | ty::Opaque, _) => {
-                                return Err(TypeError::CyclicTy(source_ty));
-                            }
-                            _ => bug!("generalized `{source_ty:?} to infer, not an alias"),
-                        }
+                let Some(source_alias) = source_term.to_alias_term() else {
+                    bug!("generalized `{source_term:?} to infer, not an alias");
+                };
+                match source_alias.kind(self.tcx) {
+                    ty::AliasTermKind::ProjectionTy | ty::AliasTermKind::ProjectionConst => {
+                        // FIXME: This does not handle subtyping correctly, we could
+                        // instead create a new inference variable `?normalized_source`, emitting
+                        // `Projection(normalized_source, ?ty_normalized)` and
+                        // `?normalized_source <: generalized_term`.
+                        relation.register_predicates([ty::ProjectionPredicate {
+                            projection_term: source_alias,
+                            term: generalized_term,
+                        }]);
+                    }
+                    // The old solver only accepts projection predicates for associated types.
+                    ty::AliasTermKind::InherentTy
+                    | ty::AliasTermKind::FreeTy
+                    | ty::AliasTermKind::OpaqueTy => {
+                        return Err(TypeError::CyclicTy(source_term.expect_type()));
                     }
-                    ty::TermKind::Const(source_ct) => {
-                        return Err(TypeError::CyclicConst(source_ct));
+                    ty::AliasTermKind::InherentConst
+                    | ty::AliasTermKind::FreeConst
+                    | ty::AliasTermKind::UnevaluatedConst => {
+                        return Err(TypeError::CyclicConst(source_term.expect_const()));
                     }
                 }
             }
         } else {
-            // Constrain `b_vid` to the generalized type `generalized_ty`.
-            self.instantiate(target_vid, generalized_term);
+            // Constrain `b_vid` to the generalized type `generalized_term`.
+            self.union_var_term(target_vid, generalized_term);
 
             // NOTE: The `instantiation_variance` is not the same variance as
             // used by the relation. When instantiating `b`, `target_is_expected`
             // is flipped and the `instantiation_variance` is also flipped. To
-            // constrain the `generalized_ty` while using the original relation,
+            // constrain the `generalized_term` while using the original relation,
             // we therefore only have to flip the arguments.
             //
             // ```ignore (not code)
@@ -308,7 +285,9 @@ impl<'tcx> InferCtxt<'tcx> {
         Ok(())
     }
 
-    fn equate(&self, l: TermVid, r: TermVid) {
+    /// This is a thin wrapper around inserting into the var tables. You probably want
+    /// [`Self::instantiate_var`] instead, which calls this method.
+    fn union_vars(&self, l: TermVid, r: TermVid) {
         match (l, r) {
             (TermVid::Ty(l), TermVid::Ty(r)) => {
                 self.inner.borrow_mut().type_variables().equate(l, r)
@@ -320,7 +299,9 @@ impl<'tcx> InferCtxt<'tcx> {
         }
     }
 
-    fn instantiate(&self, l: TermVid, r: ty::Term<'tcx>) {
+    /// This is a thin wrapper around inserting into the var tables. You probably want
+    /// [`Self::instantiate_var`] instead, which calls this method.
+    fn union_var_term(&self, l: TermVid, r: ty::Term<'tcx>) {
         match (l, r.kind()) {
             (TermVid::Ty(l), ty::TermKind::Ty(r)) => {
                 self.inner.borrow_mut().type_variables().instantiate(l, r)

compiler/rustc_middle/src/ty/consts.rs

@@ -323,10 +323,6 @@ impl<'tcx> Const<'tcx> {
         matches!(self.kind(), ty::ConstKind::Infer(_))
     }
 
-    pub fn is_ct_var(self) -> bool {
-        matches!(self.kind(), ConstKind::Infer(ty::InferConst::Var(_)))
-    }
-
     pub fn ct_vid(self) -> Option<ty::ConstVid> {
         match self.kind() {
             ConstKind::Infer(ty::InferConst::Var(vid)) => Some(vid),

compiler/rustc_middle/src/ty/mod.rs

@@ -621,6 +621,13 @@ impl<'tcx> Term<'tcx> {
         }
     }
 
+    pub fn term_vid(self) -> Option<TermVid> {
+        match self.kind() {
+            TermKind::Ty(ty) => ty.ty_vid().map(TermVid::Ty),
+            TermKind::Const(ct) => ct.ct_vid().map(TermVid::Const),
+        }
+    }
+
     pub fn is_trivially_wf(&self, tcx: TyCtxt<'tcx>) -> bool {
         match self.kind() {
             TermKind::Ty(ty) => ty.is_trivially_wf(tcx),

compiler/rustc_type_ir/src/generic_arg.rs

@@ -18,16 +18,3 @@ pub enum GenericArgKind<I: Interner> {
 }
 
 impl<I: Interner> Eq for GenericArgKind<I> {}
-
-#[derive_where(Clone, Copy, PartialEq, Debug; I: Interner)]
-#[derive(GenericTypeVisitable)]
-#[cfg_attr(
-    feature = "nightly",
-    derive(Decodable_NoContext, Encodable_NoContext, HashStable_NoContext)
-)]
-pub enum TermKind<I: Interner> {
-    Ty(I::Ty),
-    Const(I::Const),
-}
-
-impl<I: Interner> Eq for TermKind<I> {}

compiler/rustc_type_ir/src/lib.rs

@@ -51,6 +51,7 @@ mod pattern;
 mod predicate;
 mod predicate_kind;
 mod region_kind;
+mod term;
 mod ty_info;
 mod ty_kind;
 mod upcast;
@@ -78,6 +79,7 @@ pub use predicate_kind::*;
 pub use region_kind::*;
 pub use rustc_ast_ir::{FloatTy, IntTy, Movability, Mutability, Pinnedness, UintTy};
 use rustc_type_ir_macros::GenericTypeVisitable;
+pub use term::*;
 pub use ty_info::*;
 pub use ty_kind::*;
 pub use upcast::*;

compiler/rustc_type_ir/src/term.rs

@@ -0,0 +1,37 @@
+use derive_where::derive_where;
+#[cfg(feature = "nightly")]
+use rustc_macros::{Decodable_NoContext, Encodable_NoContext, HashStable_NoContext};
+use rustc_type_ir_macros::GenericTypeVisitable;
+
+use crate::{ConstVid, Interner, TyVid};
+
+#[derive_where(Clone, Copy, PartialEq, Debug; I: Interner)]
+#[derive(GenericTypeVisitable)]
+#[cfg_attr(
+    feature = "nightly",
+    derive(Decodable_NoContext, Encodable_NoContext, HashStable_NoContext)
+)]
+pub enum TermKind<I: Interner> {
+    Ty(I::Ty),
+    Const(I::Const),
+}
+
+impl<I: Interner> Eq for TermKind<I> {}
+
+#[derive(Copy, Clone, Eq, PartialEq, Debug)]
+pub enum TermVid {
+    Ty(TyVid),
+    Const(ConstVid),
+}
+
+impl From<TyVid> for TermVid {
+    fn from(value: TyVid) -> Self {
+        TermVid::Ty(value)
+    }
+}
+
+impl From<ConstVid> for TermVid {
+    fn from(value: ConstVid) -> Self {
+        TermVid::Const(value)
+    }
+}