1 files changed, 92 insertions, 62 deletions

diff --git a/crates/hir_ty/src/infer/unify.rs b/crates/hir_ty/src/infer/unify.rs
index 75250a369..2ea9dd920 100644
--- a/crates/hir_ty/src/infer/unify.rs
+++ b/crates/hir_ty/src/infer/unify.rs
@@ -7,8 +7,9 @@ use ena::unify::{InPlaceUnificationTable, NoError, UnifyKey, UnifyValue};
 
 use super::{DomainGoal, InferenceContext};
 use crate::{
-    AliasEq, AliasTy, BoundVar, Canonical, CanonicalVarKinds, DebruijnIndex, FnPointer,
-    InEnvironment, InferenceVar, Interner, Scalar, Substitution, Ty, TyKind, TypeWalk, WhereClause,
+    AliasEq, AliasTy, BoundVar, Canonical, CanonicalVarKinds, DebruijnIndex, FnPointer, FnSubst,
+    InEnvironment, InferenceVar, Interner, Scalar, Substitution, Ty, TyExt, TyKind, TypeWalk,
+    WhereClause,
 };
 
 impl<'a> InferenceContext<'a> {
@@ -49,9 +50,9 @@ impl<'a, 'b> Canonicalizer<'a, 'b> {
 
     fn do_canonicalize<T: TypeWalk>(&mut self, t: T, binders: DebruijnIndex) -> T {
         t.fold_binders(
-            &mut |ty, binders| match ty.interned(&Interner) {
+            &mut |ty, binders| match ty.kind(&Interner) {
                 &TyKind::InferenceVar(var, kind) => {
-                    let inner = var.to_inner();
+                    let inner = from_inference_var(var);
                     if self.var_stack.contains(&inner) {
                         // recursive type
                         return self.ctx.table.type_variable_table.fallback_value(var, kind);
@@ -65,7 +66,7 @@ impl<'a, 'b> Canonicalizer<'a, 'b> {
                         result
                     } else {
                         let root = self.ctx.table.var_unification_table.find(inner);
-                        let position = self.add(InferenceVar::from_inner(root), kind);
+                        let position = self.add(to_inference_var(root), kind);
                         TyKind::BoundVar(BoundVar::new(binders, position)).intern(&Interner)
                     }
                 }
@@ -108,19 +109,22 @@ impl<'a, 'b> Canonicalizer<'a, 'b> {
 }
 
 impl<T> Canonicalized<T> {
-    pub(super) fn decanonicalize_ty(&self, mut ty: Ty) -> Ty {
-        ty.walk_mut_binders(
+    pub(super) fn decanonicalize_ty(&self, ty: Ty) -> Ty {
+        ty.fold_binders(
             &mut |ty, binders| {
-                if let &mut TyKind::BoundVar(bound) = ty.interned_mut() {
+                if let TyKind::BoundVar(bound) = ty.kind(&Interner) {
                     if bound.debruijn >= binders {
                         let (v, k) = self.free_vars[bound.index];
-                        *ty = TyKind::InferenceVar(v, k).intern(&Interner);
+                        TyKind::InferenceVar(v, k).intern(&Interner)
+                    } else {
+                        ty
                     }
+                } else {
+                    ty
                 }
             },
             DebruijnIndex::INNERMOST,
-        );
-        ty
+        )
     }
 
     pub(super) fn apply_solution(
@@ -129,52 +133,56 @@ impl<T> Canonicalized<T> {
         solution: Canonical<Substitution>,
     ) {
         // the solution may contain new variables, which we need to convert to new inference vars
-        let new_vars = Substitution(
-            solution
-                .binders
-                .iter(&Interner)
-                .map(|k| match k.kind {
-                    VariableKind::Ty(TyVariableKind::General) => ctx.table.new_type_var(),
-                    VariableKind::Ty(TyVariableKind::Integer) => ctx.table.new_integer_var(),
-                    VariableKind::Ty(TyVariableKind::Float) => ctx.table.new_float_var(),
-                    // HACK: Chalk can sometimes return new lifetime variables. We
-                    // want to just skip them, but to not mess up the indices of
-                    // other variables, we'll just create a new type variable in
-                    // their place instead. This should not matter (we never see the
-                    // actual *uses* of the lifetime variable).
-                    VariableKind::Lifetime => ctx.table.new_type_var(),
-                    _ => panic!("const variable in solution"),
-                })
-                .collect(),
+        let new_vars = Substitution::from_iter(
+            &Interner,
+            solution.binders.iter(&Interner).map(|k| match k.kind {
+                VariableKind::Ty(TyVariableKind::General) => ctx.table.new_type_var(),
+                VariableKind::Ty(TyVariableKind::Integer) => ctx.table.new_integer_var(),
+                VariableKind::Ty(TyVariableKind::Float) => ctx.table.new_float_var(),
+                // HACK: Chalk can sometimes return new lifetime variables. We
+                // want to just skip them, but to not mess up the indices of
+                // other variables, we'll just create a new type variable in
+                // their place instead. This should not matter (we never see the
+                // actual *uses* of the lifetime variable).
+                VariableKind::Lifetime => ctx.table.new_type_var(),
+                _ => panic!("const variable in solution"),
+            }),
         );
-        for (i, ty) in solution.value.into_iter().enumerate() {
+        for (i, ty) in solution.value.iter(&Interner).enumerate() {
             let (v, k) = self.free_vars[i];
             // eagerly replace projections in the type; we may be getting types
             // e.g. from where clauses where this hasn't happened yet
-            let ty = ctx.normalize_associated_types_in(ty.clone().subst_bound_vars(&new_vars));
+            let ty = ctx.normalize_associated_types_in(
+                new_vars.apply(ty.assert_ty_ref(&Interner).clone(), &Interner),
+            );
             ctx.table.unify(&TyKind::InferenceVar(v, k).intern(&Interner), &ty);
         }
     }
 }
 
+pub fn could_unify(t1: &Ty, t2: &Ty) -> bool {
+    InferenceTable::new().unify(t1, t2)
+}
+
 pub(crate) fn unify(tys: &Canonical<(Ty, Ty)>) -> Option<Substitution> {
     let mut table = InferenceTable::new();
-    let vars = Substitution(
+    let vars = Substitution::from_iter(
+        &Interner,
         tys.binders
             .iter(&Interner)
             // we always use type vars here because we want everything to
             // fallback to Unknown in the end (kind of hacky, as below)
-            .map(|_| table.new_type_var())
-            .collect(),
+            .map(|_| table.new_type_var()),
     );
-    let ty1_with_vars = tys.value.0.clone().subst_bound_vars(&vars);
-    let ty2_with_vars = tys.value.1.clone().subst_bound_vars(&vars);
+    let ty1_with_vars = vars.apply(tys.value.0.clone(), &Interner);
+    let ty2_with_vars = vars.apply(tys.value.1.clone(), &Interner);
     if !table.unify(&ty1_with_vars, &ty2_with_vars) {
         return None;
     }
     // default any type vars that weren't unified back to their original bound vars
     // (kind of hacky)
-    for (i, var) in vars.iter().enumerate() {
+    for (i, var) in vars.iter(&Interner).enumerate() {
+        let var = var.assert_ty_ref(&Interner);
         if &*table.resolve_ty_shallow(var) == var {
             table.unify(
                 var,
@@ -182,11 +190,11 @@ pub(crate) fn unify(tys: &Canonical<(Ty, Ty)>) -> Option<Substitution> {
             );
         }
     }
-    Some(
-        Substitution::builder(tys.binders.len(&Interner))
-            .fill(vars.iter().map(|v| table.resolve_ty_completely(v.clone())))
-            .build(),
-    )
+    Some(Substitution::from_iter(
+        &Interner,
+        vars.iter(&Interner)
+            .map(|v| table.resolve_ty_completely(v.assert_ty_ref(&Interner).clone())),
+    ))
 }
 
 #[derive(Clone, Debug)]
@@ -200,17 +208,17 @@ impl TypeVariableTable {
     }
 
     pub(super) fn set_diverging(&mut self, iv: InferenceVar, diverging: bool) {
-        self.inner[iv.to_inner().0 as usize].diverging = diverging;
+        self.inner[from_inference_var(iv).0 as usize].diverging = diverging;
     }
 
     fn is_diverging(&mut self, iv: InferenceVar) -> bool {
-        self.inner[iv.to_inner().0 as usize].diverging
+        self.inner[from_inference_var(iv).0 as usize].diverging
     }
 
     fn fallback_value(&self, iv: InferenceVar, kind: TyVariableKind) -> Ty {
         match kind {
-            _ if self.inner[iv.to_inner().0 as usize].diverging => TyKind::Never,
-            TyVariableKind::General => TyKind::Unknown,
+            _ if self.inner[from_inference_var(iv).0 as usize].diverging => TyKind::Never,
+            TyVariableKind::General => TyKind::Error,
             TyVariableKind::Integer => TyKind::Scalar(Scalar::Int(IntTy::I32)),
             TyVariableKind::Float => TyKind::Scalar(Scalar::Float(FloatTy::F64)),
         }
@@ -227,6 +235,7 @@ pub(crate) struct TypeVariableData {
 pub(crate) struct InferenceTable {
     pub(super) var_unification_table: InPlaceUnificationTable<TypeVarId>,
     pub(super) type_variable_table: TypeVariableTable,
+    pub(super) revision: u32,
 }
 
 impl InferenceTable {
@@ -234,6 +243,7 @@ impl InferenceTable {
         InferenceTable {
             var_unification_table: InPlaceUnificationTable::new(),
             type_variable_table: TypeVariableTable { inner: Vec::new() },
+            revision: 0,
         }
     }
 
@@ -241,7 +251,7 @@ impl InferenceTable {
         self.type_variable_table.push(TypeVariableData { diverging });
         let key = self.var_unification_table.new_key(TypeVarValue::Unknown);
         assert_eq!(key.0 as usize, self.type_variable_table.inner.len() - 1);
-        TyKind::InferenceVar(InferenceVar::from_inner(key), kind).intern(&Interner)
+        TyKind::InferenceVar(to_inference_var(key), kind).intern(&Interner)
     }
 
     pub(crate) fn new_type_var(&mut self) -> Ty {
@@ -278,7 +288,9 @@ impl InferenceTable {
         substs2: &Substitution,
         depth: usize,
     ) -> bool {
-        substs1.0.iter().zip(substs2.0.iter()).all(|(t1, t2)| self.unify_inner(t1, t2, depth))
+        substs1.iter(&Interner).zip(substs2.iter(&Interner)).all(|(t1, t2)| {
+            self.unify_inner(t1.assert_ty_ref(&Interner), t2.assert_ty_ref(&Interner), depth)
+        })
     }
 
     fn unify_inner(&mut self, ty1: &Ty, ty2: &Ty, depth: usize) -> bool {
@@ -293,12 +305,12 @@ impl InferenceTable {
         let ty1 = self.resolve_ty_shallow(ty1);
         let ty2 = self.resolve_ty_shallow(ty2);
         if ty1.equals_ctor(&ty2) {
-            match (ty1.interned(&Interner), ty2.interned(&Interner)) {
+            match (ty1.kind(&Interner), ty2.kind(&Interner)) {
                 (TyKind::Adt(_, substs1), TyKind::Adt(_, substs2))
                 | (TyKind::FnDef(_, substs1), TyKind::FnDef(_, substs2))
                 | (
-                    TyKind::Function(FnPointer { substs: substs1, .. }),
-                    TyKind::Function(FnPointer { substs: substs2, .. }),
+                    TyKind::Function(FnPointer { substitution: FnSubst(substs1), .. }),
+                    TyKind::Function(FnPointer { substitution: FnSubst(substs2), .. }),
                 )
                 | (TyKind::Tuple(_, substs1), TyKind::Tuple(_, substs2))
                 | (TyKind::OpaqueType(_, substs1), TyKind::OpaqueType(_, substs2))
@@ -306,9 +318,11 @@ impl InferenceTable {
                 | (TyKind::Closure(.., substs1), TyKind::Closure(.., substs2)) => {
                     self.unify_substs(substs1, substs2, depth + 1)
                 }
-                (TyKind::Ref(_, ty1), TyKind::Ref(_, ty2))
+                (TyKind::Array(ty1, c1), TyKind::Array(ty2, c2)) if c1 == c2 => {
+                    self.unify_inner(ty1, ty2, depth + 1)
+                }
+                (TyKind::Ref(_, _, ty1), TyKind::Ref(_, _, ty2))
                 | (TyKind::Raw(_, ty1), TyKind::Raw(_, ty2))
-                | (TyKind::Array(ty1), TyKind::Array(ty2))
                 | (TyKind::Slice(ty1), TyKind::Slice(ty2)) => self.unify_inner(ty1, ty2, depth + 1),
                 _ => true, /* we checked equals_ctor already */
             }
@@ -318,8 +332,8 @@ impl InferenceTable {
     }
 
     pub(super) fn unify_inner_trivial(&mut self, ty1: &Ty, ty2: &Ty, depth: usize) -> bool {
-        match (ty1.interned(&Interner), ty2.interned(&Interner)) {
-            (TyKind::Unknown, _) | (_, TyKind::Unknown) => true,
+        match (ty1.kind(&Interner), ty2.kind(&Interner)) {
+            (TyKind::Error, _) | (_, TyKind::Error) => true,
 
             (TyKind::Placeholder(p1), TyKind::Placeholder(p2)) if *p1 == *p2 => true,
 
@@ -356,7 +370,14 @@ impl InferenceTable {
                 == self.type_variable_table.is_diverging(*tv2) =>
             {
                 // both type vars are unknown since we tried to resolve them
-                self.var_unification_table.union(tv1.to_inner(), tv2.to_inner());
+                if !self
+                    .var_unification_table
+                    .unioned(from_inference_var(*tv1), from_inference_var(*tv2))
+                {
+                    self.var_unification_table
+                        .union(from_inference_var(*tv1), from_inference_var(*tv2));
+                    self.revision += 1;
+                }
                 true
             }
 
@@ -391,9 +412,10 @@ impl InferenceTable {
             ) => {
                 // the type var is unknown since we tried to resolve it
                 self.var_unification_table.union_value(
-                    tv.to_inner(),
+                    from_inference_var(*tv),
                     TypeVarValue::Known(other.clone().intern(&Interner)),
                 );
+                self.revision += 1;
                 true
             }
 
@@ -443,9 +465,9 @@ impl InferenceTable {
             if i > 0 {
                 cov_mark::hit!(type_var_resolves_to_int_var);
             }
-            match ty.interned(&Interner) {
+            match ty.kind(&Interner) {
                 TyKind::InferenceVar(tv, _) => {
-                    let inner = tv.to_inner();
+                    let inner = from_inference_var(*tv);
                     match self.var_unification_table.inlined_probe_value(inner).known() {
                         Some(known_ty) => {
                             // The known_ty can't be a type var itself
@@ -466,9 +488,9 @@ impl InferenceTable {
     /// be resolved as far as possible, i.e. contain no type variables with
     /// known type.
     fn resolve_ty_as_possible_inner(&mut self, tv_stack: &mut Vec<TypeVarId>, ty: Ty) -> Ty {
-        ty.fold(&mut |ty| match ty.interned(&Interner) {
+        ty.fold(&mut |ty| match ty.kind(&Interner) {
             &TyKind::InferenceVar(tv, kind) => {
-                let inner = tv.to_inner();
+                let inner = from_inference_var(tv);
                 if tv_stack.contains(&inner) {
                     cov_mark::hit!(type_var_cycles_resolve_as_possible);
                     // recursive type
@@ -493,9 +515,9 @@ impl InferenceTable {
     /// Resolves the type completely; type variables without known type are
     /// replaced by TyKind::Unknown.
     fn resolve_ty_completely_inner(&mut self, tv_stack: &mut Vec<TypeVarId>, ty: Ty) -> Ty {
-        ty.fold(&mut |ty| match ty.interned(&Interner) {
+        ty.fold(&mut |ty| match ty.kind(&Interner) {
             &TyKind::InferenceVar(tv, kind) => {
-                let inner = tv.to_inner();
+                let inner = from_inference_var(tv);
                 if tv_stack.contains(&inner) {
                     cov_mark::hit!(type_var_cycles_resolve_completely);
                     // recursive type
@@ -538,6 +560,14 @@ impl UnifyKey for TypeVarId {
     }
 }
 
+fn from_inference_var(var: InferenceVar) -> TypeVarId {
+    TypeVarId(var.index())
+}
+
+fn to_inference_var(TypeVarId(index): TypeVarId) -> InferenceVar {
+    index.into()
+}
+
 /// The value of a type variable: either we already know the type, or we don't
 /// know it yet.
 #[derive(Clone, PartialEq, Eq, Debug)]