Assume TyKind::General in EnaVariable::to_ty

Author: AzureMarker

chalk-solve/src/infer.rs

@@ -218,7 +218,7 @@ impl<I: Interner> ParameterEnaVariableExt<I> for ParameterEnaVariable<I> {
         // we are matching on kind, so skipping it is fine
         let ena_variable = self.skip_kind();
         match &self.kind {
-            VariableKind::Ty(kind) => ena_variable.to_ty(interner, *kind).cast(interner),
+            VariableKind::Ty(kind) => ena_variable.to_ty_with_kind(interner, *kind).cast(interner),
             VariableKind::Lifetime => ena_variable.to_lifetime(interner).cast(interner),
             VariableKind::Const(ty) => ena_variable.to_const(interner, ty.clone()).cast(interner),
         }

chalk-solve/src/infer/invert.rs

@@ -150,7 +150,7 @@ where
             .inverted_ty
             .entry(universe)
             .or_insert_with(|| table.new_variable(universe.ui))
-            .to_ty(self.interner(), TyKind::General)
+            .to_ty(self.interner())
             .shifted_in(self.interner()))
     }
 

chalk-solve/src/infer/test.rs

@@ -9,8 +9,8 @@ fn infer() {
     let interner = &ChalkIr;
     let mut table: InferenceTable<ChalkIr> = InferenceTable::new();
     let environment0 = Environment::new(interner);
-    let a = table.new_variable(U0).to_ty(interner, TyKind::General);
-    let b = table.new_variable(U0).to_ty(interner, TyKind::General);
+    let a = table.new_variable(U0).to_ty(interner);
+    let b = table.new_variable(U0).to_ty(interner);
     table
         .unify(interner, &environment0, &a, &ty!(apply (item 0) (expr b)))
         .unwrap();
@@ -33,7 +33,7 @@ fn universe_error() {
     let interner = &ChalkIr;
     let mut table: InferenceTable<ChalkIr> = InferenceTable::new();
     let environment0 = Environment::new(interner);
-    let a = table.new_variable(U0).to_ty(interner, TyKind::General);
+    let a = table.new_variable(U0).to_ty(interner);
     table
         .unify(interner, &environment0, &a, &ty!(placeholder 1))
         .unwrap_err();
@@ -45,7 +45,7 @@ fn cycle_error() {
     let interner = &ChalkIr;
     let mut table: InferenceTable<ChalkIr> = InferenceTable::new();
     let environment0 = Environment::new(interner);
-    let a = table.new_variable(U0).to_ty(interner, TyKind::General);
+    let a = table.new_variable(U0).to_ty(interner);
     table
         .unify(interner, &environment0, &a, &ty!(apply (item 0) (expr a)))
         .unwrap_err();
@@ -62,8 +62,8 @@ fn cycle_indirect() {
     let interner = &ChalkIr;
     let mut table: InferenceTable<ChalkIr> = InferenceTable::new();
     let environment0 = Environment::new(interner);
-    let a = table.new_variable(U0).to_ty(interner, TyKind::General);
-    let b = table.new_variable(U0).to_ty(interner, TyKind::General);
+    let a = table.new_variable(U0).to_ty(interner);
+    let b = table.new_variable(U0).to_ty(interner);
     table
         .unify(interner, &environment0, &a, &ty!(apply (item 0) (expr b)))
         .unwrap();
@@ -76,8 +76,8 @@ fn universe_error_indirect_1() {
     let interner = &ChalkIr;
     let mut table: InferenceTable<ChalkIr> = InferenceTable::new();
     let environment0 = Environment::new(interner);
-    let a = table.new_variable(U0).to_ty(interner, TyKind::General);
-    let b = table.new_variable(U1).to_ty(interner, TyKind::General);
+    let a = table.new_variable(U0).to_ty(interner);
+    let b = table.new_variable(U1).to_ty(interner);
     table
         .unify(interner, &environment0, &b, &ty!(placeholder 1))
         .unwrap();
@@ -90,8 +90,8 @@ fn universe_error_indirect_2() {
     let interner = &ChalkIr;
     let mut table: InferenceTable<ChalkIr> = InferenceTable::new();
     let environment0 = Environment::new(interner);
-    let a = table.new_variable(U0).to_ty(interner, TyKind::General);
-    let b = table.new_variable(U1).to_ty(interner, TyKind::General);
+    let a = table.new_variable(U0).to_ty(interner);
+    let b = table.new_variable(U1).to_ty(interner);
     table.unify(interner, &environment0, &a, &b).unwrap();
     table
         .unify(interner, &environment0, &b, &ty!(placeholder 1))
@@ -104,8 +104,8 @@ fn universe_promote() {
     let interner = &ChalkIr;
     let mut table: InferenceTable<ChalkIr> = InferenceTable::new();
     let environment0 = Environment::new(interner);
-    let a = table.new_variable(U0).to_ty(interner, TyKind::General);
-    let b = table.new_variable(U1).to_ty(interner, TyKind::General);
+    let a = table.new_variable(U0).to_ty(interner);
+    let b = table.new_variable(U1).to_ty(interner);
     table
         .unify(interner, &environment0, &a, &ty!(apply (item 0) (expr b)))
         .unwrap();
@@ -125,8 +125,8 @@ fn universe_promote_bad() {
     let interner = &ChalkIr;
     let mut table: InferenceTable<ChalkIr> = InferenceTable::new();
     let environment0 = Environment::new(interner);
-    let a = table.new_variable(U0).to_ty(interner, TyKind::General);
-    let b = table.new_variable(U1).to_ty(interner, TyKind::General);
+    let a = table.new_variable(U0).to_ty(interner);
+    let b = table.new_variable(U1).to_ty(interner);
     table
         .unify(interner, &environment0, &a, &ty!(apply (item 0) (expr b)))
         .unwrap();
@@ -143,7 +143,7 @@ fn projection_eq() {
     let interner = &ChalkIr;
     let mut table: InferenceTable<ChalkIr> = InferenceTable::new();
     let environment0 = Environment::new(interner);
-    let a = table.new_variable(U0).to_ty(interner, TyKind::General);
+    let a = table.new_variable(U0).to_ty(interner);
 
     // expect an error ("cycle during unification")
     table
@@ -199,10 +199,10 @@ fn quantify_bound() {
     let mut table = make_table();
     let environment0 = Environment::new(interner);
 
-    let v0 = table.new_variable(U0).to_ty(interner, TyKind::General);
-    let v1 = table.new_variable(U1).to_ty(interner, TyKind::General);
-    let v2a = table.new_variable(U2).to_ty(interner, TyKind::General);
-    let v2b = table.new_variable(U2).to_ty(interner, TyKind::General);
+    let v0 = table.new_variable(U0).to_ty(interner);
+    let v1 = table.new_variable(U1).to_ty(interner);
+    let v2a = table.new_variable(U2).to_ty(interner);
+    let v2b = table.new_variable(U2).to_ty(interner);
 
     table
         .unify(
@@ -248,8 +248,8 @@ fn quantify_ty_under_binder() {
         .unify(
             interner,
             &environment0,
-            &v0.to_ty(interner, TyKind::General),
-            &v1.to_ty(interner, TyKind::General),
+            &v0.to_ty(interner),
+            &v1.to_ty(interner),
         )
         .unwrap();
 

chalk-solve/src/infer/unify.rs

@@ -630,7 +630,7 @@ where
                         .unwrap();
                 }
 
-                Ok(var.to_ty(interner, kind))
+                Ok(var.to_ty_with_kind(interner, kind))
             }
         }
     }

chalk-solve/src/infer/var.rs

@@ -54,10 +54,17 @@ impl<I: Interner> EnaVariable<I> {
     /// Convert this inference variable into a type. When using this
     /// method, naturally you should know from context that the kind
     /// of this inference variable is a type (we can't check it).
-    pub(crate) fn to_ty(self, interner: &I, kind: TyKind) -> Ty<I> {
+    pub(crate) fn to_ty_with_kind(self, interner: &I, kind: TyKind) -> Ty<I> {
         self.var.to_ty(interner, kind)
     }
 
+    /// Same as `to_ty_with_kind`, but the kind is set to `TyKind::General`.
+    /// This should be used instead of `to_ty_with_kind` when creating a new
+    /// inference variable (when the kind is not known).
+    pub(crate) fn to_ty(self, interner: &I) -> Ty<I> {
+        self.var.to_ty(interner, TyKind::General)
+    }
+
     /// Convert this inference variable into a lifetime. When using this
     /// method, naturally you should know from context that the kind
     /// of this inference variable is a lifetime (we can't check it).

chalk-solve/src/solve/slg/aggregate.rs

@@ -478,9 +478,7 @@ impl<I: Interner> AntiUnifier<'_, '_, I> {
 
     fn new_ty_variable(&mut self) -> Ty<I> {
         let interner = self.interner;
-        self.infer
-            .new_variable(self.universe)
-            .to_ty(interner, TyKind::General)
+        self.infer.new_variable(self.universe).to_ty(interner)
     }
 
     fn new_lifetime_variable(&mut self) -> Lifetime<I> {