1 files changed, 60 insertions, 80 deletions

diff --git a/crates/hir_ty/src/traits/chalk/mapping.rs b/crates/hir_ty/src/traits/chalk/mapping.rs
index 8700d664e..0e9fc3265 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,11 @@ use hir_def::{type_ref::Mutability, AssocContainerId, GenericDefId, Lookup, Type
 
 use crate::{
     db::HirDatabase,
-    primitive::{FloatBitness, FloatTy, IntBitness, IntTy, Signedness},
+    primitive::{FloatTy, IntTy, UintTy},
     traits::{Canonical, Obligation},
     ApplicationTy, CallableDefId, GenericPredicate, InEnvironment, OpaqueTy, OpaqueTyId,
-    ProjectionPredicate, ProjectionTy, Substs, TraitEnvironment, TraitRef, Ty, TyKind, TypeCtor,
+    ProjectionPredicate, ProjectionTy, Scalar, Substs, TraitEnvironment, TraitRef, Ty, TyKind,
+    TypeCtor,
 };
 
 use super::interner::*;
@@ -63,19 +64,31 @@ impl ToChalk for Ty {
                     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)
-                }
+                TypeCtor::Scalar(scalar) => chalk_ir::TyKind::Scalar(match scalar {
+                    Scalar::Bool => chalk_ir::Scalar::Bool,
+                    Scalar::Char => chalk_ir::Scalar::Char,
+                    Scalar::Int(it) => chalk_ir::Scalar::Int(match it {
+                        IntTy::Isize => chalk_ir::IntTy::Isize,
+                        IntTy::I8 => chalk_ir::IntTy::I8,
+                        IntTy::I16 => chalk_ir::IntTy::I16,
+                        IntTy::I32 => chalk_ir::IntTy::I32,
+                        IntTy::I64 => chalk_ir::IntTy::I64,
+                        IntTy::I128 => chalk_ir::IntTy::I128,
+                    }),
+                    Scalar::Uint(it) => chalk_ir::Scalar::Uint(match it {
+                        UintTy::Usize => chalk_ir::UintTy::Usize,
+                        UintTy::U8 => chalk_ir::UintTy::U8,
+                        UintTy::U16 => chalk_ir::UintTy::U16,
+                        UintTy::U32 => chalk_ir::UintTy::U32,
+                        UintTy::U64 => chalk_ir::UintTy::U64,
+                        UintTy::U128 => chalk_ir::UintTy::U128,
+                    }),
+                    Scalar::Float(it) => chalk_ir::Scalar::Float(match it {
+                        FloatTy::F32 => chalk_ir::FloatTy::F32,
+                        FloatTy::F64 => chalk_ir::FloatTy::F64,
+                    }),
+                })
+                .intern(&Interner),
 
                 TypeCtor::Tuple { cardinality } => {
                     let substitution = apply_ty.parameters.to_chalk(db);
@@ -219,21 +232,37 @@ impl ToChalk for Ty {
                 apply_ty_from_chalk(db, TypeCtor::OpaqueType(from_chalk(db, opaque_type_id)), 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(chalk_ir::Scalar::Bool) => {
+                Ty::simple(TypeCtor::Scalar(Scalar::Bool))
+            }
+            chalk_ir::TyKind::Scalar(chalk_ir::Scalar::Char) => {
+                Ty::simple(TypeCtor::Scalar(Scalar::Char))
+            }
+            chalk_ir::TyKind::Scalar(chalk_ir::Scalar::Int(int_ty)) => {
+                Ty::simple(TypeCtor::Scalar(Scalar::Int(match int_ty {
+                    chalk_ir::IntTy::Isize => IntTy::Isize,
+                    chalk_ir::IntTy::I8 => IntTy::I8,
+                    chalk_ir::IntTy::I16 => IntTy::I16,
+                    chalk_ir::IntTy::I32 => IntTy::I32,
+                    chalk_ir::IntTy::I64 => IntTy::I64,
+                    chalk_ir::IntTy::I128 => IntTy::I128,
+                })))
             }
-            chalk_ir::TyKind::Scalar(Scalar::Float(chalk_ir::FloatTy::F64)) => {
-                Ty::simple(TypeCtor::Float(FloatTy { bitness: FloatBitness::X64 }))
+            chalk_ir::TyKind::Scalar(chalk_ir::Scalar::Uint(int_ty)) => {
+                Ty::simple(TypeCtor::Scalar(Scalar::Uint(match int_ty {
+                    chalk_ir::UintTy::Usize => UintTy::Usize,
+                    chalk_ir::UintTy::U8 => UintTy::U8,
+                    chalk_ir::UintTy::U16 => UintTy::U16,
+                    chalk_ir::UintTy::U32 => UintTy::U32,
+                    chalk_ir::UintTy::U64 => UintTy::U64,
+                    chalk_ir::UintTy::U128 => UintTy::U128,
+                })))
+            }
+            chalk_ir::TyKind::Scalar(chalk_ir::Scalar::Float(float_ty)) => {
+                Ty::simple(TypeCtor::Scalar(Scalar::Float(match float_ty {
+                    chalk_ir::FloatTy::F32 => FloatTy::F32,
+                    chalk_ir::FloatTy::F64 => FloatTy::F64,
+                })))
             }
             chalk_ir::TyKind::Tuple(cardinality, subst) => {
                 apply_ty_from_chalk(db, TypeCtor::Tuple { cardinality: cardinality as u16 }, subst)
@@ -293,7 +322,7 @@ fn ref_to_chalk(
 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);
+        chalk_ir::TyKind::Scalar(chalk_ir::Scalar::Uint(chalk_ir::UintTy::Usize)).intern(&Interner);
     let const_ = chalk_ir::ConstData {
         ty: usize_ty,
         value: chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst { interned: () }),
@@ -364,55 +393,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 {