1 files changed, 99 insertions, 211 deletions

diff --git a/crates/hir_ty/src/traits/chalk/mapping.rs b/crates/hir_ty/src/traits/chalk/mapping.rs
index 8700d664e..6e6055d80 100644
--- a/crates/hir_ty/src/traits/chalk/mapping.rs
+++ b/crates/hir_ty/src/traits/chalk/mapping.rs
@@ -4,7 +4,7 @@
 //! conversions.
 
 use chalk_ir::{
-    cast::Cast, fold::shift::Shift, interner::HasInterner, LifetimeData, PlaceholderIndex, Scalar,
+    cast::Cast, fold::shift::Shift, interner::HasInterner, LifetimeData, PlaceholderIndex,
     UniverseIndex,
 };
 use chalk_solve::rust_ir;
@@ -14,10 +14,10 @@ use hir_def::{type_ref::Mutability, AssocContainerId, GenericDefId, Lookup, Type
 
 use crate::{
     db::HirDatabase,
-    primitive::{FloatBitness, FloatTy, IntBitness, IntTy, Signedness},
+    primitive::UintTy,
     traits::{Canonical, Obligation},
-    ApplicationTy, CallableDefId, GenericPredicate, InEnvironment, OpaqueTy, OpaqueTyId,
-    ProjectionPredicate, ProjectionTy, Substs, TraitEnvironment, TraitRef, Ty, TyKind, TypeCtor,
+    AliasTy, CallableDefId, FnPointer, FnSig, GenericPredicate, InEnvironment, OpaqueTy,
+    OpaqueTyId, ProjectionPredicate, ProjectionTy, Scalar, Substs, TraitEnvironment, TraitRef, Ty,
 };
 
 use super::interner::*;
@@ -27,88 +27,68 @@ impl ToChalk for Ty {
     type Chalk = chalk_ir::Ty<Interner>;
     fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Ty<Interner> {
         match self {
-            Ty::Apply(apply_ty) => match apply_ty.ctor {
-                TypeCtor::Ref(m) => ref_to_chalk(db, m, apply_ty.parameters),
-                TypeCtor::Array => array_to_chalk(db, apply_ty.parameters),
-                TypeCtor::FnPtr { num_args: _, is_varargs } => {
-                    let substitution =
-                        chalk_ir::FnSubst(apply_ty.parameters.to_chalk(db).shifted_in(&Interner));
-                    chalk_ir::TyKind::Function(chalk_ir::FnPointer {
-                        num_binders: 0,
-                        sig: chalk_ir::FnSig {
-                            abi: (),
-                            safety: chalk_ir::Safety::Safe,
-                            variadic: is_varargs,
-                        },
-                        substitution,
-                    })
-                    .intern(&Interner)
-                }
-                TypeCtor::AssociatedType(type_alias) => {
-                    let assoc_type = TypeAliasAsAssocType(type_alias);
-                    let assoc_type_id = assoc_type.to_chalk(db);
-                    let substitution = apply_ty.parameters.to_chalk(db);
-                    chalk_ir::TyKind::AssociatedType(assoc_type_id, substitution).intern(&Interner)
-                }
+            Ty::Ref(m, parameters) => ref_to_chalk(db, m, parameters),
+            Ty::Array(parameters) => array_to_chalk(db, parameters),
+            Ty::Function(FnPointer { sig: FnSig { variadic }, substs, .. }) => {
+                let substitution = chalk_ir::FnSubst(substs.to_chalk(db).shifted_in(&Interner));
+                chalk_ir::TyKind::Function(chalk_ir::FnPointer {
+                    num_binders: 0,
+                    sig: chalk_ir::FnSig { abi: (), safety: chalk_ir::Safety::Safe, variadic },
+                    substitution,
+                })
+                .intern(&Interner)
+            }
+            Ty::AssociatedType(type_alias, substs) => {
+                let assoc_type = TypeAliasAsAssocType(type_alias);
+                let assoc_type_id = assoc_type.to_chalk(db);
+                let substitution = substs.to_chalk(db);
+                chalk_ir::TyKind::AssociatedType(assoc_type_id, substitution).intern(&Interner)
+            }
 
-                TypeCtor::OpaqueType(impl_trait_id) => {
-                    let id = impl_trait_id.to_chalk(db);
-                    let substitution = apply_ty.parameters.to_chalk(db);
-                    chalk_ir::TyKind::OpaqueType(id, substitution).intern(&Interner)
-                }
+            Ty::OpaqueType(impl_trait_id, substs) => {
+                let id = impl_trait_id.to_chalk(db);
+                let substitution = substs.to_chalk(db);
+                chalk_ir::TyKind::OpaqueType(id, substitution).intern(&Interner)
+            }
 
-                TypeCtor::ForeignType(type_alias) => {
-                    let foreign_type = TypeAliasAsForeignType(type_alias);
-                    let foreign_type_id = foreign_type.to_chalk(db);
-                    chalk_ir::TyKind::Foreign(foreign_type_id).intern(&Interner)
-                }
+            Ty::ForeignType(type_alias) => {
+                let foreign_type = TypeAliasAsForeignType(type_alias);
+                let foreign_type_id = foreign_type.to_chalk(db);
+                chalk_ir::TyKind::Foreign(foreign_type_id).intern(&Interner)
+            }
 
-                TypeCtor::Bool => chalk_ir::TyKind::Scalar(Scalar::Bool).intern(&Interner),
-                TypeCtor::Char => chalk_ir::TyKind::Scalar(Scalar::Char).intern(&Interner),
-                TypeCtor::Int(int_ty) => {
-                    chalk_ir::TyKind::Scalar(int_ty_to_chalk(int_ty)).intern(&Interner)
-                }
-                TypeCtor::Float(FloatTy { bitness: FloatBitness::X32 }) => {
-                    chalk_ir::TyKind::Scalar(Scalar::Float(chalk_ir::FloatTy::F32))
-                        .intern(&Interner)
-                }
-                TypeCtor::Float(FloatTy { bitness: FloatBitness::X64 }) => {
-                    chalk_ir::TyKind::Scalar(Scalar::Float(chalk_ir::FloatTy::F64))
-                        .intern(&Interner)
-                }
+            Ty::Scalar(scalar) => chalk_ir::TyKind::Scalar(scalar).intern(&Interner),
 
-                TypeCtor::Tuple { cardinality } => {
-                    let substitution = apply_ty.parameters.to_chalk(db);
-                    chalk_ir::TyKind::Tuple(cardinality.into(), substitution).intern(&Interner)
-                }
-                TypeCtor::RawPtr(mutability) => {
-                    let ty = apply_ty.parameters[0].clone().to_chalk(db);
-                    chalk_ir::TyKind::Raw(mutability.to_chalk(db), ty).intern(&Interner)
-                }
-                TypeCtor::Slice => {
-                    chalk_ir::TyKind::Slice(apply_ty.parameters[0].clone().to_chalk(db))
-                        .intern(&Interner)
-                }
-                TypeCtor::Str => chalk_ir::TyKind::Str.intern(&Interner),
-                TypeCtor::FnDef(callable_def) => {
-                    let id = callable_def.to_chalk(db);
-                    let substitution = apply_ty.parameters.to_chalk(db);
-                    chalk_ir::TyKind::FnDef(id, substitution).intern(&Interner)
-                }
-                TypeCtor::Never => chalk_ir::TyKind::Never.intern(&Interner),
+            Ty::Tuple(cardinality, substs) => {
+                let substitution = substs.to_chalk(db);
+                chalk_ir::TyKind::Tuple(cardinality.into(), substitution).intern(&Interner)
+            }
+            Ty::Raw(mutability, substs) => {
+                let ty = substs[0].clone().to_chalk(db);
+                chalk_ir::TyKind::Raw(mutability.to_chalk(db), ty).intern(&Interner)
+            }
+            Ty::Slice(substs) => {
+                chalk_ir::TyKind::Slice(substs[0].clone().to_chalk(db)).intern(&Interner)
+            }
+            Ty::Str => chalk_ir::TyKind::Str.intern(&Interner),
+            Ty::FnDef(callable_def, substs) => {
+                let id = callable_def.to_chalk(db);
+                let substitution = substs.to_chalk(db);
+                chalk_ir::TyKind::FnDef(id, substitution).intern(&Interner)
+            }
+            Ty::Never => chalk_ir::TyKind::Never.intern(&Interner),
 
-                TypeCtor::Closure { def, expr } => {
-                    let closure_id = db.intern_closure((def, expr));
-                    let substitution = apply_ty.parameters.to_chalk(db);
-                    chalk_ir::TyKind::Closure(closure_id.into(), substitution).intern(&Interner)
-                }
+            Ty::Closure(def, expr, substs) => {
+                let closure_id = db.intern_closure((def, expr));
+                let substitution = substs.to_chalk(db);
+                chalk_ir::TyKind::Closure(closure_id.into(), substitution).intern(&Interner)
+            }
 
-                TypeCtor::Adt(adt_id) => {
-                    let substitution = apply_ty.parameters.to_chalk(db);
-                    chalk_ir::TyKind::Adt(chalk_ir::AdtId(adt_id), substitution).intern(&Interner)
-                }
-            },
-            Ty::Projection(proj_ty) => {
+            Ty::Adt(adt_id, substs) => {
+                let substitution = substs.to_chalk(db);
+                chalk_ir::TyKind::Adt(chalk_ir::AdtId(adt_id), substitution).intern(&Interner)
+            }
+            Ty::Alias(AliasTy::Projection(proj_ty)) => {
                 let associated_ty_id = TypeAliasAsAssocType(proj_ty.associated_ty).to_chalk(db);
                 let substitution = proj_ty.parameters.to_chalk(db);
                 chalk_ir::AliasTy::Projection(chalk_ir::ProjectionTy {
@@ -126,8 +106,8 @@ impl ToChalk for Ty {
                 }
                 .to_ty::<Interner>(&Interner)
             }
-            Ty::Bound(idx) => chalk_ir::TyKind::BoundVar(idx).intern(&Interner),
-            Ty::Infer(_infer_ty) => panic!("uncanonicalized infer ty"),
+            Ty::BoundVar(idx) => chalk_ir::TyKind::BoundVar(idx).intern(&Interner),
+            Ty::InferenceVar(..) => panic!("uncanonicalized infer ty"),
             Ty::Dyn(predicates) => {
                 let where_clauses = chalk_ir::QuantifiedWhereClauses::from_iter(
                     &Interner,
@@ -139,7 +119,7 @@ impl ToChalk for Ty {
                 };
                 chalk_ir::TyKind::Dyn(bounded_ty).intern(&Interner)
             }
-            Ty::Opaque(opaque_ty) => {
+            Ty::Alias(AliasTy::Opaque(opaque_ty)) => {
                 let opaque_ty_id = opaque_ty.opaque_ty_id.to_chalk(db);
                 let substitution = opaque_ty.parameters.to_chalk(db);
                 chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Opaque(chalk_ir::OpaqueTy {
@@ -154,9 +134,7 @@ impl ToChalk for Ty {
     fn from_chalk(db: &dyn HirDatabase, chalk: chalk_ir::Ty<Interner>) -> Self {
         match chalk.data(&Interner).kind.clone() {
             chalk_ir::TyKind::Error => Ty::Unknown,
-            chalk_ir::TyKind::Array(ty, _size) => {
-                Ty::apply(TypeCtor::Array, Substs::single(from_chalk(db, ty)))
-            }
+            chalk_ir::TyKind::Array(ty, _size) => Ty::Array(Substs::single(from_chalk(db, ty))),
             chalk_ir::TyKind::Placeholder(idx) => {
                 assert_eq!(idx.ui, UniverseIndex::ROOT);
                 let interned_id = crate::db::GlobalTypeParamId::from_intern_id(
@@ -168,12 +146,12 @@ impl ToChalk for Ty {
                 let associated_ty =
                     from_chalk::<TypeAliasAsAssocType, _>(db, proj.associated_ty_id).0;
                 let parameters = from_chalk(db, proj.substitution);
-                Ty::Projection(ProjectionTy { associated_ty, parameters })
+                Ty::Alias(AliasTy::Projection(ProjectionTy { associated_ty, parameters }))
             }
             chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Opaque(opaque_ty)) => {
                 let impl_trait_id = from_chalk(db, opaque_ty.opaque_ty_id);
                 let parameters = from_chalk(db, opaque_ty.substitution);
-                Ty::Opaque(OpaqueTy { opaque_ty_id: impl_trait_id, parameters })
+                Ty::Alias(AliasTy::Opaque(OpaqueTy { opaque_ty_id: impl_trait_id, parameters }))
             }
             chalk_ir::TyKind::Function(chalk_ir::FnPointer {
                 num_binders,
@@ -182,19 +160,17 @@ impl ToChalk for Ty {
                 ..
             }) => {
                 assert_eq!(num_binders, 0);
-                let parameters: Substs = from_chalk(
+                let substs: Substs = from_chalk(
                     db,
                     substitution.0.shifted_out(&Interner).expect("fn ptr should have no binders"),
                 );
-                Ty::Apply(ApplicationTy {
-                    ctor: TypeCtor::FnPtr {
-                        num_args: (parameters.len() - 1) as u16,
-                        is_varargs: variadic,
-                    },
-                    parameters,
+                Ty::Function(FnPointer {
+                    num_args: (substs.len() - 1),
+                    sig: FnSig { variadic },
+                    substs,
                 })
             }
-            chalk_ir::TyKind::BoundVar(idx) => Ty::Bound(idx),
+            chalk_ir::TyKind::BoundVar(idx) => Ty::BoundVar(idx),
             chalk_ir::TyKind::InferenceVar(_iv, _kind) => Ty::Unknown,
             chalk_ir::TyKind::Dyn(where_clauses) => {
                 assert_eq!(where_clauses.bounds.binders.len(&Interner), 1);
@@ -207,75 +183,49 @@ impl ToChalk for Ty {
                 Ty::Dyn(predicates)
             }
 
-            chalk_ir::TyKind::Adt(struct_id, subst) => {
-                apply_ty_from_chalk(db, TypeCtor::Adt(struct_id.0), subst)
-            }
-            chalk_ir::TyKind::AssociatedType(type_id, subst) => apply_ty_from_chalk(
-                db,
-                TypeCtor::AssociatedType(from_chalk::<TypeAliasAsAssocType, _>(db, type_id).0),
-                subst,
+            chalk_ir::TyKind::Adt(struct_id, subst) => Ty::Adt(struct_id.0, from_chalk(db, subst)),
+            chalk_ir::TyKind::AssociatedType(type_id, subst) => Ty::AssociatedType(
+                from_chalk::<TypeAliasAsAssocType, _>(db, type_id).0,
+                from_chalk(db, subst),
             ),
+
             chalk_ir::TyKind::OpaqueType(opaque_type_id, subst) => {
-                apply_ty_from_chalk(db, TypeCtor::OpaqueType(from_chalk(db, opaque_type_id)), subst)
+                Ty::OpaqueType(from_chalk(db, opaque_type_id), from_chalk(db, subst))
             }
 
-            chalk_ir::TyKind::Scalar(Scalar::Bool) => Ty::simple(TypeCtor::Bool),
-            chalk_ir::TyKind::Scalar(Scalar::Char) => Ty::simple(TypeCtor::Char),
-            chalk_ir::TyKind::Scalar(Scalar::Int(int_ty)) => Ty::simple(TypeCtor::Int(IntTy {
-                signedness: Signedness::Signed,
-                bitness: bitness_from_chalk_int(int_ty),
-            })),
-            chalk_ir::TyKind::Scalar(Scalar::Uint(uint_ty)) => Ty::simple(TypeCtor::Int(IntTy {
-                signedness: Signedness::Unsigned,
-                bitness: bitness_from_chalk_uint(uint_ty),
-            })),
-            chalk_ir::TyKind::Scalar(Scalar::Float(chalk_ir::FloatTy::F32)) => {
-                Ty::simple(TypeCtor::Float(FloatTy { bitness: FloatBitness::X32 }))
-            }
-            chalk_ir::TyKind::Scalar(Scalar::Float(chalk_ir::FloatTy::F64)) => {
-                Ty::simple(TypeCtor::Float(FloatTy { bitness: FloatBitness::X64 }))
-            }
+            chalk_ir::TyKind::Scalar(scalar) => Ty::Scalar(scalar),
             chalk_ir::TyKind::Tuple(cardinality, subst) => {
-                apply_ty_from_chalk(db, TypeCtor::Tuple { cardinality: cardinality as u16 }, subst)
+                Ty::Tuple(cardinality, from_chalk(db, subst))
             }
             chalk_ir::TyKind::Raw(mutability, ty) => {
-                Ty::apply_one(TypeCtor::RawPtr(from_chalk(db, mutability)), from_chalk(db, ty))
+                Ty::Raw(from_chalk(db, mutability), Substs::single(from_chalk(db, ty)))
             }
-            chalk_ir::TyKind::Slice(ty) => Ty::apply_one(TypeCtor::Slice, from_chalk(db, ty)),
+            chalk_ir::TyKind::Slice(ty) => Ty::Slice(Substs::single(from_chalk(db, ty))),
             chalk_ir::TyKind::Ref(mutability, _lifetime, ty) => {
-                Ty::apply_one(TypeCtor::Ref(from_chalk(db, mutability)), from_chalk(db, ty))
+                Ty::Ref(from_chalk(db, mutability), Substs::single(from_chalk(db, ty)))
             }
-            chalk_ir::TyKind::Str => Ty::simple(TypeCtor::Str),
-            chalk_ir::TyKind::Never => Ty::simple(TypeCtor::Never),
+            chalk_ir::TyKind::Str => Ty::Str,
+            chalk_ir::TyKind::Never => Ty::Never,
 
             chalk_ir::TyKind::FnDef(fn_def_id, subst) => {
-                let callable_def = from_chalk(db, fn_def_id);
-                apply_ty_from_chalk(db, TypeCtor::FnDef(callable_def), subst)
+                Ty::FnDef(from_chalk(db, fn_def_id), from_chalk(db, subst))
             }
 
             chalk_ir::TyKind::Closure(id, subst) => {
                 let id: crate::db::ClosureId = id.into();
                 let (def, expr) = db.lookup_intern_closure(id);
-                apply_ty_from_chalk(db, TypeCtor::Closure { def, expr }, subst)
+                Ty::Closure(def, expr, from_chalk(db, subst))
             }
 
-            chalk_ir::TyKind::Foreign(foreign_def_id) => Ty::simple(TypeCtor::ForeignType(
-                from_chalk::<TypeAliasAsForeignType, _>(db, foreign_def_id).0,
-            )),
+            chalk_ir::TyKind::Foreign(foreign_def_id) => {
+                Ty::ForeignType(from_chalk::<TypeAliasAsForeignType, _>(db, foreign_def_id).0)
+            }
             chalk_ir::TyKind::Generator(_, _) => unimplemented!(), // FIXME
             chalk_ir::TyKind::GeneratorWitness(_, _) => unimplemented!(), // FIXME
         }
     }
 }
 
-fn apply_ty_from_chalk(
-    db: &dyn HirDatabase,
-    ctor: TypeCtor,
-    subst: chalk_ir::Substitution<Interner>,
-) -> Ty {
-    Ty::Apply(ApplicationTy { ctor, parameters: from_chalk(db, subst) })
-}
-
 /// We currently don't model lifetimes, but Chalk does. So, we have to insert a
 /// fake lifetime here, because Chalks built-in logic may expect it to be there.
 fn ref_to_chalk(
@@ -292,8 +242,7 @@ fn ref_to_chalk(
 /// fake constant here, because Chalks built-in logic may expect it to be there.
 fn array_to_chalk(db: &dyn HirDatabase, subst: Substs) -> chalk_ir::Ty<Interner> {
     let arg = subst[0].clone().to_chalk(db);
-    let usize_ty =
-        chalk_ir::TyKind::Scalar(Scalar::Uint(chalk_ir::UintTy::Usize)).intern(&Interner);
+    let usize_ty = chalk_ir::TyKind::Scalar(Scalar::Uint(UintTy::Usize)).intern(&Interner);
     let const_ = chalk_ir::ConstData {
         ty: usize_ty,
         value: chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst { interned: () }),
@@ -364,55 +313,6 @@ impl ToChalk for OpaqueTyId {
     }
 }
 
-fn bitness_from_chalk_uint(uint_ty: chalk_ir::UintTy) -> IntBitness {
-    use chalk_ir::UintTy;
-
-    match uint_ty {
-        UintTy::Usize => IntBitness::Xsize,
-        UintTy::U8 => IntBitness::X8,
-        UintTy::U16 => IntBitness::X16,
-        UintTy::U32 => IntBitness::X32,
-        UintTy::U64 => IntBitness::X64,
-        UintTy::U128 => IntBitness::X128,
-    }
-}
-
-fn bitness_from_chalk_int(int_ty: chalk_ir::IntTy) -> IntBitness {
-    use chalk_ir::IntTy;
-
-    match int_ty {
-        IntTy::Isize => IntBitness::Xsize,
-        IntTy::I8 => IntBitness::X8,
-        IntTy::I16 => IntBitness::X16,
-        IntTy::I32 => IntBitness::X32,
-        IntTy::I64 => IntBitness::X64,
-        IntTy::I128 => IntBitness::X128,
-    }
-}
-
-fn int_ty_to_chalk(int_ty: IntTy) -> Scalar {
-    use chalk_ir::{IntTy, UintTy};
-
-    match int_ty.signedness {
-        Signedness::Signed => Scalar::Int(match int_ty.bitness {
-            IntBitness::Xsize => IntTy::Isize,
-            IntBitness::X8 => IntTy::I8,
-            IntBitness::X16 => IntTy::I16,
-            IntBitness::X32 => IntTy::I32,
-            IntBitness::X64 => IntTy::I64,
-            IntBitness::X128 => IntTy::I128,
-        }),
-        Signedness::Unsigned => Scalar::Uint(match int_ty.bitness {
-            IntBitness::Xsize => UintTy::Usize,
-            IntBitness::X8 => UintTy::U8,
-            IntBitness::X16 => UintTy::U16,
-            IntBitness::X32 => UintTy::U32,
-            IntBitness::X64 => UintTy::U64,
-            IntBitness::X128 => UintTy::U128,
-        }),
-    }
-}
-
 impl ToChalk for Mutability {
     type Chalk = chalk_ir::Mutability;
     fn to_chalk(self, _db: &dyn HirDatabase) -> Self::Chalk {
@@ -632,20 +532,12 @@ where
     type Chalk = chalk_ir::Canonical<T::Chalk>;
 
     fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Canonical<T::Chalk> {
-        let kinds = self
-            .kinds
-            .iter()
-            .map(|k| match k {
-                TyKind::General => chalk_ir::TyVariableKind::General,
-                TyKind::Integer => chalk_ir::TyVariableKind::Integer,
-                TyKind::Float => chalk_ir::TyVariableKind::Float,
-            })
-            .map(|tk| {
-                chalk_ir::CanonicalVarKind::new(
-                    chalk_ir::VariableKind::Ty(tk),
-                    chalk_ir::UniverseIndex::ROOT,
-                )
-            });
+        let kinds = self.kinds.iter().map(|&tk| {
+            chalk_ir::CanonicalVarKind::new(
+                chalk_ir::VariableKind::Ty(tk),
+                chalk_ir::UniverseIndex::ROOT,
+            )
+        });
         let value = self.value.to_chalk(db);
         chalk_ir::Canonical {
             value,
@@ -658,17 +550,13 @@ where
             .binders
             .iter(&Interner)
             .map(|k| match k.kind {
-                chalk_ir::VariableKind::Ty(tk) => match tk {
-                    chalk_ir::TyVariableKind::General => TyKind::General,
-                    chalk_ir::TyVariableKind::Integer => TyKind::Integer,
-                    chalk_ir::TyVariableKind::Float => TyKind::Float,
-                },
+                chalk_ir::VariableKind::Ty(tk) => tk,
                 // 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).
-                chalk_ir::VariableKind::Lifetime => TyKind::General,
+                chalk_ir::VariableKind::Lifetime => chalk_ir::TyVariableKind::General,
                 chalk_ir::VariableKind::Const(_) => panic!("unexpected const from Chalk"),
             })
             .collect();