Use chalk_ir::Scalar directly

crates/hir_ty/src/display.rs

@@ -3,9 +3,9 @@
 use std::{borrow::Cow, fmt};
 
 use crate::{
-    db::HirDatabase, utils::generics, ApplicationTy, CallableDefId, FnSig, GenericPredicate,
+    db::HirDatabase, primitive, utils::generics, ApplicationTy, CallableDefId, FnSig,
-    Lifetime, Obligation, OpaqueTy, OpaqueTyId, ProjectionTy, Scalar, Substs, TraitRef, Ty,
+    GenericPredicate, Lifetime, Obligation, OpaqueTy, OpaqueTyId, ProjectionTy, Scalar, Substs,
-    TypeCtor,
+    TraitRef, Ty, TypeCtor,
 };
 use arrayvec::ArrayVec;
 use hir_def::{
@@ -244,9 +244,11 @@ impl HirDisplay for ApplicationTy {
         match self.ctor {
             TypeCtor::Scalar(Scalar::Bool) => write!(f, "bool")?,
             TypeCtor::Scalar(Scalar::Char) => write!(f, "char")?,
-            TypeCtor::Scalar(Scalar::Float(t)) => write!(f, "{}", t)?,
+            TypeCtor::Scalar(Scalar::Float(t)) => {
-            TypeCtor::Scalar(Scalar::Int(t)) => write!(f, "{}", t)?,
+                write!(f, "{}", primitive::float_ty_to_string(t))?
-            TypeCtor::Scalar(Scalar::Uint(t)) => write!(f, "{}", t)?,
+            }
+            TypeCtor::Scalar(Scalar::Int(t)) => write!(f, "{}", primitive::int_ty_to_string(t))?,
+            TypeCtor::Scalar(Scalar::Uint(t)) => write!(f, "{}", primitive::uint_ty_to_string(t))?,
             TypeCtor::Str => write!(f, "str")?,
             TypeCtor::Slice => {
                 let t = self.parameters.as_single();

crates/hir_ty/src/infer/expr.rs

@@ -15,7 +15,7 @@ use test_utils::mark;
 
 use crate::{
     autoderef, method_resolution, op,
-    primitive::UintTy,
+    primitive::{self, UintTy},
     traits::{FnTrait, InEnvironment},
     utils::{generics, variant_data, Generics},
     ApplicationTy, Binders, CallableDefId, InferTy, Mutability, Obligation, OpaqueTyId, Rawness,
@@ -730,17 +730,21 @@ impl<'a> InferenceContext<'a> {
                 }
                 Literal::Char(..) => Ty::simple(TypeCtor::Scalar(Scalar::Char)),
                 Literal::Int(_v, ty) => match ty {
-                    Some(int_ty) => Ty::simple(TypeCtor::Scalar(Scalar::Int((*int_ty).into()))),
+                    Some(int_ty) => Ty::simple(TypeCtor::Scalar(Scalar::Int(
+                        primitive::int_ty_from_builtin(*int_ty),
+                    ))),
                     None => self.table.new_integer_var(),
                 },
                 Literal::Uint(_v, ty) => match ty {
-                    Some(int_ty) => Ty::simple(TypeCtor::Scalar(Scalar::Uint((*int_ty).into()))),
+                    Some(int_ty) => Ty::simple(TypeCtor::Scalar(Scalar::Uint(
+                        primitive::uint_ty_from_builtin(*int_ty),
+                    ))),
                     None => self.table.new_integer_var(),
                 },
                 Literal::Float(_v, ty) => match ty {
-                    Some(float_ty) => {
+                    Some(float_ty) => Ty::simple(TypeCtor::Scalar(Scalar::Float(
-                        Ty::simple(TypeCtor::Scalar(Scalar::Float((*float_ty).into())))
+                        primitive::float_ty_from_builtin(*float_ty),
-                    }
+                    ))),
                     None => self.table.new_float_var(),
                 },
             },

crates/hir_ty/src/lib.rs

@@ -38,7 +38,6 @@ use itertools::Itertools;
 use crate::{
     db::HirDatabase,
     display::HirDisplay,
-    primitive::{FloatTy, IntTy, UintTy},
     utils::{generics, make_mut_slice, Generics},
 };
 
@@ -50,7 +49,7 @@ pub use lower::{
 };
 pub use traits::{InEnvironment, Obligation, ProjectionPredicate, TraitEnvironment};
 
-pub use chalk_ir::{BoundVar, DebruijnIndex};
+pub use chalk_ir::{BoundVar, DebruijnIndex, Scalar};
 
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub enum Lifetime {
@@ -58,17 +57,6 @@ pub enum Lifetime {
     Static,
 }
 
-/// Types of scalar values.
-#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[allow(missing_docs)]
-pub enum Scalar {
-    Bool,
-    Char,
-    Int(IntTy),
-    Uint(UintTy),
-    Float(FloatTy),
-}
-
 /// A type constructor or type name: this might be something like the primitive
 /// type `bool`, a struct like `Vec`, or things like function pointers or
 /// tuples.
@@ -736,9 +724,13 @@ impl Ty {
             BuiltinType::Char => TypeCtor::Scalar(Scalar::Char),
             BuiltinType::Bool => TypeCtor::Scalar(Scalar::Bool),
             BuiltinType::Str => TypeCtor::Str,
-            BuiltinType::Int(t) => TypeCtor::Scalar(Scalar::Int(t.into())),
+            BuiltinType::Int(t) => TypeCtor::Scalar(Scalar::Int(primitive::int_ty_from_builtin(t))),
-            BuiltinType::Uint(t) => TypeCtor::Scalar(Scalar::Uint(t.into())),
+            BuiltinType::Uint(t) => {
-            BuiltinType::Float(t) => TypeCtor::Scalar(Scalar::Float(t.into())),
+                TypeCtor::Scalar(Scalar::Uint(primitive::uint_ty_from_builtin(t)))
+            }
+            BuiltinType::Float(t) => {
+                TypeCtor::Scalar(Scalar::Float(primitive::float_ty_from_builtin(t)))
+            }
         })
     }
 

crates/hir_ty/src/method_resolution.rs

@@ -16,7 +16,7 @@ use rustc_hash::{FxHashMap, FxHashSet};
 use crate::{
     autoderef,
     db::HirDatabase,
-    primitive::{FloatTy, IntTy, UintTy},
+    primitive::{self, FloatTy, IntTy, UintTy},
     utils::all_super_traits,
     ApplicationTy, Canonical, DebruijnIndex, InEnvironment, Scalar, Substs, TraitEnvironment,
     TraitRef, Ty, TyKind, TypeCtor, TypeWalk,
@@ -225,8 +225,12 @@ impl Ty {
                     FloatTy::F32 => lang_item_crate!("f32", "f32_runtime"),
                     FloatTy::F64 => lang_item_crate!("f64", "f64_runtime"),
                 },
-                TypeCtor::Scalar(Scalar::Int(t)) => lang_item_crate!(t.ty_to_string()),
+                TypeCtor::Scalar(Scalar::Int(t)) => {
-                TypeCtor::Scalar(Scalar::Uint(t)) => lang_item_crate!(t.ty_to_string()),
+                    lang_item_crate!(primitive::int_ty_to_string(t))
+                }
+                TypeCtor::Scalar(Scalar::Uint(t)) => {
+                    lang_item_crate!(primitive::uint_ty_to_string(t))
+                }
                 TypeCtor::Str => lang_item_crate!("str_alloc", "str"),
                 TypeCtor::Slice => lang_item_crate!("slice_alloc", "slice"),
                 TypeCtor::RawPtr(Mutability::Shared) => lang_item_crate!("const_ptr"),

crates/hir_ty/src/primitive.rs

@@ -3,41 +3,11 @@
 //! * during type inference, they can be uncertain (ie, `let x = 92;`)
 //! * they don't belong to any particular crate.
 
-use std::fmt;
+pub use chalk_ir::{FloatTy, IntTy, UintTy};
-
 pub use hir_def::builtin_type::{BuiltinFloat, BuiltinInt, BuiltinUint};
 
-/// Different signed int types.
+pub fn int_ty_to_string(ty: IntTy) -> &'static str {
-#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+    match ty {
-pub enum IntTy {
-    Isize,
-    I8,
-    I16,
-    I32,
-    I64,
-    I128,
-}
-
-/// Different unsigned int types.
-#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum UintTy {
-    Usize,
-    U8,
-    U16,
-    U32,
-    U64,
-    U128,
-}
-
-impl fmt::Display for IntTy {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.ty_to_string())
-    }
-}
-
-impl IntTy {
-    pub fn ty_to_string(self) -> &'static str {
-        match self {
         IntTy::Isize => "isize",
         IntTy::I8 => "i8",
         IntTy::I16 => "i16",
@@ -46,17 +16,9 @@ impl IntTy {
         IntTy::I128 => "i128",
     }
 }
-}
 
-impl fmt::Display for UintTy {
+pub fn uint_ty_to_string(ty: UintTy) -> &'static str {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    match ty {
-        write!(f, "{}", self.ty_to_string())
-    }
-}
-
-impl UintTy {
-    pub fn ty_to_string(self) -> &'static str {
-        match self {
         UintTy::Usize => "usize",
         UintTy::U8 => "u8",
         UintTy::U16 => "u16",
@@ -65,66 +27,39 @@ impl UintTy {
         UintTy::U128 => "u128",
     }
 }
-}
 
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub fn float_ty_to_string(ty: FloatTy) -> &'static str {
-pub enum FloatTy {
+    match ty {
-    F32,
-    F64,
-}
-
-impl fmt::Debug for FloatTy {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Display::fmt(self, f)
-    }
-}
-
-impl fmt::Display for FloatTy {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.ty_to_string())
-    }
-}
-
-impl FloatTy {
-    pub fn ty_to_string(self) -> &'static str {
-        match self {
         FloatTy::F32 => "f32",
         FloatTy::F64 => "f64",
     }
 }
-}
 
-impl From<BuiltinInt> for IntTy {
+pub(super) fn int_ty_from_builtin(t: BuiltinInt) -> IntTy {
-    fn from(t: BuiltinInt) -> Self {
     match t {
-            BuiltinInt::Isize => Self::Isize,
+        BuiltinInt::Isize => IntTy::Isize,
-            BuiltinInt::I8 => Self::I8,
+        BuiltinInt::I8 => IntTy::I8,
-            BuiltinInt::I16 => Self::I16,
+        BuiltinInt::I16 => IntTy::I16,
-            BuiltinInt::I32 => Self::I32,
+        BuiltinInt::I32 => IntTy::I32,
-            BuiltinInt::I64 => Self::I64,
+        BuiltinInt::I64 => IntTy::I64,
-            BuiltinInt::I128 => Self::I128,
+        BuiltinInt::I128 => IntTy::I128,
-        }
     }
 }
 
-impl From<BuiltinUint> for UintTy {
+pub(super) fn uint_ty_from_builtin(t: BuiltinUint) -> UintTy {
-    fn from(t: BuiltinUint) -> Self {
     match t {
-            BuiltinUint::Usize => Self::Usize,
+        BuiltinUint::Usize => UintTy::Usize,
-            BuiltinUint::U8 => Self::U8,
+        BuiltinUint::U8 => UintTy::U8,
-            BuiltinUint::U16 => Self::U16,
+        BuiltinUint::U16 => UintTy::U16,
-            BuiltinUint::U32 => Self::U32,
+        BuiltinUint::U32 => UintTy::U32,
-            BuiltinUint::U64 => Self::U64,
+        BuiltinUint::U64 => UintTy::U64,
-            BuiltinUint::U128 => Self::U128,
+        BuiltinUint::U128 => UintTy::U128,
-        }
     }
 }
 
-impl From<BuiltinFloat> for FloatTy {
+pub(super) fn float_ty_from_builtin(t: BuiltinFloat) -> FloatTy {
-    fn from(t: BuiltinFloat) -> Self {
     match t {
-            BuiltinFloat::F32 => Self::F32,
+        BuiltinFloat::F32 => FloatTy::F32,
-            BuiltinFloat::F64 => Self::F64,
+        BuiltinFloat::F64 => FloatTy::F64,
-        }
     }
 }

crates/hir_ty/src/traits/chalk/mapping.rs

@@ -14,7 +14,7 @@ use hir_def::{type_ref::Mutability, AssocContainerId, GenericDefId, Lookup, Type
 
 use crate::{
     db::HirDatabase,
-    primitive::{FloatTy, IntTy, UintTy},
+    primitive::UintTy,
     traits::{Canonical, Obligation},
     ApplicationTy, CallableDefId, GenericPredicate, InEnvironment, OpaqueTy, OpaqueTyId,
     ProjectionPredicate, ProjectionTy, Scalar, Substs, TraitEnvironment, TraitRef, Ty, TyKind,
@@ -64,31 +64,7 @@ impl ToChalk for Ty {
                     chalk_ir::TyKind::Foreign(foreign_type_id).intern(&Interner)
                 }
 
-                TypeCtor::Scalar(scalar) => chalk_ir::TyKind::Scalar(match scalar {
+                TypeCtor::Scalar(scalar) => chalk_ir::TyKind::Scalar(scalar).intern(&Interner),
-                    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);
@@ -232,38 +208,7 @@ impl ToChalk for Ty {
                 apply_ty_from_chalk(db, TypeCtor::OpaqueType(from_chalk(db, opaque_type_id)), subst)
             }
 
-            chalk_ir::TyKind::Scalar(chalk_ir::Scalar::Bool) => {
+            chalk_ir::TyKind::Scalar(scalar) => Ty::simple(TypeCtor::Scalar(scalar)),
-                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(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)
             }
@@ -321,8 +266,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 =
+    let usize_ty = chalk_ir::TyKind::Scalar(Scalar::Uint(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: () }),