Implement float type variables

Adds new notation for float inference variables, just like what was
added for integers.
- `?0f` is a float inference variable
- `float N` is the notation for float variables in goals, for example:
  ```
  exists<float N> { ... }
  ```

Author: AzureMarker

chalk-integration/src/lowering.rs

@@ -725,6 +725,10 @@ impl LowerVariableKind for VariableKind {
                 chalk_ir::VariableKind::Ty(chalk_ir::TyKind::Integer),
                 n.str.clone(),
             ),
+            VariableKind::FloatTy(n) => chalk_ir::WithKind::new(
+                chalk_ir::VariableKind::Ty(chalk_ir::TyKind::Float),
+                n.str.clone(),
+            ),
             VariableKind::Lifetime(n) => {
                 chalk_ir::WithKind::new(chalk_ir::VariableKind::Lifetime, n.str.clone())
             }
@@ -1826,6 +1830,7 @@ impl Kinded for VariableKind {
         match *self {
             VariableKind::Ty(_) => Kind::Ty,
             VariableKind::IntegerTy(_) => Kind::Ty,
+            VariableKind::FloatTy(_) => Kind::Ty,
             VariableKind::Lifetime(_) => Kind::Lifetime,
             VariableKind::Const(_) => Kind::Const,
         }

chalk-ir/src/debug.rs

@@ -181,6 +181,7 @@ impl<I: Interner> Debug for TyData<I> {
             TyData::Dyn(clauses) => write!(fmt, "{:?}", clauses),
             TyData::InferenceVar(var, TyKind::General) => write!(fmt, "{:?}", var),
             TyData::InferenceVar(var, TyKind::Integer) => write!(fmt, "{:?}i", var),
+            TyData::InferenceVar(var, TyKind::Float) => write!(fmt, "{:?}f", var),
             TyData::Apply(apply) => write!(fmt, "{:?}", apply),
             TyData::Alias(alias) => write!(fmt, "{:?}", alias),
             TyData::Placeholder(index) => write!(fmt, "{:?}", index),
@@ -279,6 +280,7 @@ impl<'a, I: Interner> Debug for VariableKindsInnerDebug<'a, I> {
             match binder {
                 VariableKind::Ty(TyKind::General) => write!(fmt, "type")?,
                 VariableKind::Ty(TyKind::Integer) => write!(fmt, "integer type")?,
+                VariableKind::Ty(TyKind::Float) => write!(fmt, "float type")?,
                 VariableKind::Lifetime => write!(fmt, "lifetime")?,
                 VariableKind::Const(ty) => write!(fmt, "const: {:?}", ty)?,
             }
@@ -769,6 +771,7 @@ impl<I: Interner> Debug for VariableKind<I> {
         match self {
             VariableKind::Ty(TyKind::General) => write!(fmt, "type"),
             VariableKind::Ty(TyKind::Integer) => write!(fmt, "integer type"),
+            VariableKind::Ty(TyKind::Float) => write!(fmt, "float type"),
             VariableKind::Lifetime => write!(fmt, "lifetime"),
             VariableKind::Const(ty) => write!(fmt, "const: {:?}", ty),
         }
@@ -781,6 +784,7 @@ impl<I: Interner, T: Debug> Debug for WithKind<I, T> {
         match &self.kind {
             VariableKind::Ty(TyKind::General) => write!(fmt, "{:?} with kind type", value),
             VariableKind::Ty(TyKind::Integer) => write!(fmt, "{:?} with kind integer type", value),
+            VariableKind::Ty(TyKind::Float) => write!(fmt, "{:?} with kind float type", value),
             VariableKind::Lifetime => write!(fmt, "{:?} with kind lifetime", value),
             VariableKind::Const(ty) => write!(fmt, "{:?} with kind {:?}", value, ty),
         }

chalk-ir/src/lib.rs

@@ -357,6 +357,17 @@ impl<I: Interner> Ty<I> {
         }
     }
 
+    /// Returns true if this is a `FloatTy`
+    pub fn is_float(&self, interner: &I) -> bool {
+        match self.data(interner) {
+            TyData::Apply(ApplicationTy {
+                name: TypeName::Scalar(Scalar::Float(_)),
+                ..
+            }) => true,
+            _ => false,
+        }
+    }
+
     /// True if this type contains "bound" types/lifetimes, and hence
     /// needs to be shifted across binders. This is a very inefficient
     /// check, intended only for debug assertions, because I am lazy.
@@ -925,7 +936,7 @@ impl<I: Interner> ApplicationTy<I> {
     }
 }
 
-/// Represents some extra knowledge we may have about the variable.
+/// Represents some extra knowledge we may have about the type variable.
 /// ```ignore
 /// let x: &[u32];
 /// let i = 1;
@@ -939,6 +950,7 @@ impl<I: Interner> ApplicationTy<I> {
 pub enum TyKind {
     General,
     Integer,
+    Float,
 }
 
 #[derive(Clone, PartialEq, Eq, Hash)]

chalk-parse/src/ast.rs

@@ -101,6 +101,7 @@ pub struct OpaqueTyDefn {
 pub enum VariableKind {
     Ty(Identifier),
     IntegerTy(Identifier),
+    FloatTy(Identifier),
     Lifetime(Identifier),
     Const(Identifier),
 }

chalk-parse/src/parser.lalrpop

@@ -202,6 +202,7 @@ VariableKind: VariableKind = {
     LifetimeId => VariableKind::Lifetime(<>),
     "const" <id:Id> => VariableKind::Const(id),
     "int" <id:Id> => VariableKind::IntegerTy(id),
+    "float" <id:Id> => VariableKind::FloatTy(id),
 };
 
 AssocTyValue: AssocTyValue = {

chalk-solve/src/infer/unify.rs

@@ -140,10 +140,13 @@ impl<'t, I: Interner> Unifier<'t, I> {
             => {
                 let ty = ty_data.clone().intern(interner);
 
-                match (kind, ty.is_integer(interner)) {
-                    (TyKind::General, _)
+                match (kind, ty.is_integer(interner), ty.is_float(interner)) {
+                    // General inference variables can unify with any type
+                    (TyKind::General, _, _)
                     // Integer inference variables can only unify with integer types
-                    | (TyKind::Integer, true) => self.unify_var_ty(var, &ty),
+                    | (TyKind::Integer, true, _)
+                    // Float inference variables can only unify with float types
+                    | (TyKind::Float, _, true) => self.unify_var_ty(var, &ty),
                     _ => Err(NoSolution),
                 }
             }

tests/test/numerics.rs

@@ -55,3 +55,25 @@ fn integer_kind_trait() {
         }
     }
 }
+
+/// The `integer_kind_trait` test, but for floats
+#[test]
+fn float_kind_trait() {
+    test! {
+        program {
+            trait Foo {}
+            struct Bar {}
+
+            impl Foo for f32 {}
+            impl Foo for Bar {}
+        }
+
+        goal {
+            exists<float N> {
+                N: Foo
+            }
+        } yields {
+            "Unique; substitution [?0 := Float(F32)]"
+        }
+    }
+}