Merge pull request #394 from MarkMcCaskey/feature/add-scalar-to-typename

Add scalars to `TypeName`

Author: nikomatsakis

chalk-integration/src/lowering.rs

@@ -1188,6 +1188,20 @@ impl LowerTy for Ty {
                 };
                 Ok(chalk_ir::TyData::Function(function).intern(interner))
             }
+            Ty::Tuple { ref types } => Ok(chalk_ir::TyData::Apply(chalk_ir::ApplicationTy {
+                name: chalk_ir::TypeName::Tuple(types.len()),
+                substitution: chalk_ir::Substitution::from_fallible(
+                    interner,
+                    types.iter().map(|t| Ok(t.lower(env)?)),
+                )?,
+            })
+            .intern(interner)),
+
+            Ty::Scalar { ty } => Ok(chalk_ir::TyData::Apply(chalk_ir::ApplicationTy {
+                name: chalk_ir::TypeName::Scalar(ast_scalar_to_chalk_scalar(ty)),
+                substitution: chalk_ir::Substitution::empty(interner),
+            })
+            .intern(interner)),
         }
     }
 }
@@ -1542,3 +1556,30 @@ impl Kinded for chalk_ir::Parameter<ChalkIr> {
         self.data(interner).kind()
     }
 }
+
+fn ast_scalar_to_chalk_scalar(scalar: ScalarType) -> chalk_ir::Scalar {
+    match scalar {
+        ScalarType::Int(int) => chalk_ir::Scalar::Int(match int {
+            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,
+            IntTy::Isize => chalk_ir::IntTy::Isize,
+        }),
+        ScalarType::Uint(uint) => chalk_ir::Scalar::Uint(match uint {
+            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,
+            UintTy::Usize => chalk_ir::UintTy::Usize,
+        }),
+        ScalarType::Float(float) => chalk_ir::Scalar::Float(match float {
+            FloatTy::F32 => chalk_ir::FloatTy::F32,
+            FloatTy::F64 => chalk_ir::FloatTy::F64,
+        }),
+        ScalarType::Bool => chalk_ir::Scalar::Bool,
+        ScalarType::Char => chalk_ir::Scalar::Char,
+    }
+}

chalk-ir/src/debug.rs

@@ -141,6 +141,8 @@ impl<I: Interner> Debug for TypeName<I> {
         match self {
             TypeName::Struct(id) => write!(fmt, "{:?}", id),
             TypeName::AssociatedType(assoc_ty) => write!(fmt, "{:?}", assoc_ty),
+            TypeName::Scalar(scalar) => write!(fmt, "{:?}", scalar),
+            TypeName::Tuple(arity) => write!(fmt, "{:?}", arity),
             TypeName::OpaqueType(opaque_ty) => write!(fmt, "!{:?}", opaque_ty),
             TypeName::Error => write!(fmt, "{{error}}"),
         }

chalk-ir/src/fold/boring_impls.rs

@@ -243,6 +243,10 @@ copy_fold!(DebruijnIndex);
 copy_fold!(chalk_engine::TableIndex);
 copy_fold!(chalk_engine::TimeStamp);
 copy_fold!(());
+copy_fold!(UintTy);
+copy_fold!(IntTy);
+copy_fold!(FloatTy);
+copy_fold!(Scalar);
 copy_fold!(ClausePriority);
 
 #[macro_export]

chalk-ir/src/lib.rs

@@ -106,6 +106,41 @@ impl<G: HasInterner> HasInterner for InEnvironment<G> {
     type Interner = G::Interner;
 }
 
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum IntTy {
+    Isize,
+    I8,
+    I16,
+    I32,
+    I64,
+    I128,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum UintTy {
+    Usize,
+    U8,
+    U16,
+    U32,
+    U64,
+    U128,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum FloatTy {
+    F32,
+    F64,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum Scalar {
+    Bool,
+    Char,
+    Int(IntTy),
+    Uint(UintTy),
+    Float(FloatTy),
+}
+
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Fold, Visit)]
 pub enum TypeName<I: Interner> {
     /// a type like `Vec<T>`
@@ -114,6 +149,12 @@ pub enum TypeName<I: Interner> {
     /// an associated type like `Iterator::Item`; see `AssociatedType` for details
     AssociatedType(AssocTypeId<I>),
 
+    /// a scalar type like `bool` or `u32`
+    Scalar(Scalar),
+
+    /// a tuple of the given arity
+    Tuple(usize),
+
     /// a placeholder for opaque types like `impl Trait`
     OpaqueType(OpaqueTyId<I>),
 

chalk-ir/src/visit/boring_impls.rs

@@ -5,10 +5,10 @@
 //! The more interesting impls of `Visit` remain in the `visit` module.
 
 use crate::{
-    AssocTypeId, ClausePriority, DebruijnIndex, Goals, ImplId, Interner, OpaqueTyId, Parameter,
-    ParameterKind, PlaceholderIndex, ProgramClause, ProgramClauseData, ProgramClauses,
-    QuantifiedWhereClauses, QuantifierKind, StructId, Substitution, SuperVisit, TraitId,
-    UniverseIndex, Visit, VisitResult, Visitor,
+    AssocTypeId, ClausePriority, DebruijnIndex, FloatTy, Goals, ImplId, IntTy, Interner,
+    OpaqueTyId, Parameter, ParameterKind, PlaceholderIndex, ProgramClause, ProgramClauseData,
+    ProgramClauses, QuantifiedWhereClauses, QuantifierKind, Scalar, StructId, Substitution,
+    SuperVisit, TraitId, UintTy, UniverseIndex, Visit, VisitResult, Visitor,
 };
 use chalk_engine::{context::Context, ExClause, FlounderedSubgoal, Literal};
 use std::{marker::PhantomData, sync::Arc};
@@ -207,6 +207,10 @@ const_visit!(chalk_engine::TableIndex);
 const_visit!(chalk_engine::TimeStamp);
 const_visit!(ClausePriority);
 const_visit!(());
+const_visit!(Scalar);
+const_visit!(UintTy);
+const_visit!(IntTy);
+const_visit!(FloatTy);
 
 #[macro_export]
 macro_rules! id_visit {

chalk-parse/src/ast.rs

@@ -187,6 +187,47 @@ pub enum Ty {
         lifetime_names: Vec<Identifier>,
         ty: Box<Ty>,
     },
+    Tuple {
+        types: Vec<Box<Ty>>,
+    },
+    Scalar {
+        ty: ScalarType,
+    },
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub enum IntTy {
+    Isize,
+    I8,
+    I16,
+    I32,
+    I64,
+    I128,
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub enum UintTy {
+    Usize,
+    U8,
+    U16,
+    U32,
+    U64,
+    U128,
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub enum FloatTy {
+    F32,
+    F64,
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub enum ScalarType {
+    Bool,
+    Char,
+    Int(IntTy),
+    Uint(UintTy),
+    Float(FloatTy),
 }
 
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]

chalk-parse/src/parser.lalrpop

@@ -193,6 +193,7 @@ pub Ty: Ty = {
 };
 
 TyWithoutFor: Ty = {
+    <ScalarType> => Ty::Scalar { ty: <> },
     <n:Id> => Ty::Id { name: n},
     "fn" "(" <t:Ty> ")" => Ty::ForAll {
         lifetime_names: vec![],
@@ -203,7 +204,37 @@ TyWithoutFor: Ty = {
     },
     <n:Id> "<" <a:Comma<Parameter>> ">" => Ty::Apply { name: n, args: a },
     <p:ProjectionTy> => Ty::Projection { proj: p },
-    "(" <Ty> ")",
+    "(" <t:TupleOrParensInner> ")" => t,
+};
+
+ScalarType: ScalarType = {
+   "u8" => ScalarType::Uint(UintTy::U8),
+   "u16" => ScalarType::Uint(UintTy::U16),
+   "u32" => ScalarType::Uint(UintTy::U32),
+   "u64" => ScalarType::Uint(UintTy::U64),
+   "u128" => ScalarType::Uint(UintTy::U128),
+   "usize" => ScalarType::Uint(UintTy::Usize),
+   "i8" => ScalarType::Int(IntTy::I8),
+   "i16" => ScalarType::Int(IntTy::I16),
+   "i32" => ScalarType::Int(IntTy::I32),
+   "i64" => ScalarType::Int(IntTy::I64),
+   "i128" => ScalarType::Int(IntTy::I128),
+   "isize" => ScalarType::Int(IntTy::Isize),
+   "f32" => ScalarType::Float(FloatTy::F32),
+   "f64" => ScalarType::Float(FloatTy::F64),
+   "bool" => ScalarType::Bool,
+   "char" => ScalarType::Char,
+};
+
+TupleOrParensInner: Ty = {
+    <Ty>,
+    <first:Ty> "," <rest:Comma<Ty>> => {
+        let mut types = Vec::with_capacity(rest.len() + 1);
+        types.push(Box::new(first));
+        types.extend(rest.into_iter().map(Box::new));
+        Ty::Tuple { types }
+    },
+    () => Ty::Tuple { types: vec![] },
 };
 
 Lifetime: Lifetime = {

chalk-solve/src/clauses.rs

@@ -416,7 +416,7 @@ fn match_ty<I: Interner>(
 ) -> Result<(), Floundered> {
     let interner = builder.interner();
     Ok(match ty.data(interner) {
-        TyData::Apply(application_ty) => match_type_name(builder, application_ty.name),
+        TyData::Apply(application_ty) => match_type_name(builder, interner, application_ty),
         TyData::Placeholder(_) => {
             builder.push_clause(WellFormed::Ty(ty.clone()), Some(FromEnv::Ty(ty.clone())));
         }
@@ -442,8 +442,12 @@ fn match_ty<I: Interner>(
     })
 }
 
-fn match_type_name<I: Interner>(builder: &mut ClauseBuilder<'_, I>, name: TypeName<I>) {
-    match name {
+fn match_type_name<I: Interner>(
+    builder: &mut ClauseBuilder<'_, I>,
+    interner: &I,
+    application: &ApplicationTy<I>,
+) {
+    match application.name {
         TypeName::Struct(struct_id) => match_struct(builder, struct_id),
         TypeName::OpaqueType(opaque_ty_id) => builder
             .db
@@ -454,6 +458,10 @@ fn match_type_name<I: Interner>(builder: &mut ClauseBuilder<'_, I>, name: TypeNa
             .db
             .associated_ty_data(type_id)
             .to_program_clauses(builder),
+        TypeName::Scalar(_) => {
+            builder.push_fact(WellFormed::Ty(application.clone().intern(interner)))
+        }
+        TypeName::Tuple(_) => (),
     }
 }
 

chalk-solve/src/clauses/env_elaborator.rs

@@ -61,7 +61,7 @@ impl<'me, I: Interner> Visitor<'me, I> for EnvElaborator<'me, I> {
         let interner = self.db.interner();
         match ty.data(interner) {
             TyData::Apply(application_ty) => {
-                match_type_name(&mut self.builder, application_ty.name)
+                match_type_name(&mut self.builder, interner, application_ty)
             }
             TyData::Alias(alias_ty) => match_alias_ty(&mut self.builder, alias_ty),
             TyData::Placeholder(_) => {}

libstd.chalk

@@ -10,12 +10,10 @@ trait Clone { }
 trait Copy where Self: Clone { }
 trait Sized { }
 
-struct i32 { }
 impl Copy for i32 { }
 impl Clone for i32 { }
 impl Sized for i32 { }
 
-struct u32 { }
 impl Copy for u32 { }
 impl Clone for u32 { }
 impl Sized for u32 { }