Fix up from merge; address feedback; some tests still failing

Author: MarkMcCaskey

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/parser.lalrpop

@@ -204,7 +204,6 @@ TyWithoutFor: Ty = {
     },
     <n:Id> "<" <a:Comma<Parameter>> ">" => Ty::Apply { name: n, args: a },
     <p:ProjectionTy> => Ty::Projection { proj: p },
-    <a:AliasTy> => Ty::Alias { alias: a },
     "(" <t:TupleOrParensInner> ")" => t,
 };
 

tests/test/projection.rs

@@ -129,10 +129,9 @@ fn projection_equality() {
             trait Trait2<T> { }
             impl<T, U> Trait2<T> for U where U: Trait1<Type = T> {}
 
-            struct Foo {}
             struct S {}
             impl Trait1 for S {
-                type Type = Foo;
+                type Type = u32;
             }
         }
 
@@ -144,7 +143,7 @@ fn projection_equality() {
             // this is wrong, chalk#234
             "Ambiguous"
         } yields[SolverChoice::recursive()] {
-            "Unique; substitution [?0 := u32]"
+            "Unique; substitution [?0 := Uint(U32)]"
         }
 
         goal {
@@ -155,7 +154,7 @@ fn projection_equality() {
             // this is wrong, chalk#234
             "Ambiguous"
         } yields[SolverChoice::recursive()] {
-            "Unique; substitution [?0 := u32]"
+            "Unique; substitution [?0 := Uint(U32)]"
         }
     }
 }
@@ -168,7 +167,6 @@ fn projection_equality_priority1() {
                 type Type;
             }
 
-            struct u32 {}
             struct S1 {}
             struct S2 {}
             struct S3 {}
@@ -196,7 +194,7 @@ fn projection_equality_priority1() {
             // constrained `T` at all? I can't come up with
             // an example where that's the case, so maybe
             // not. -Niko
-            "Unique; substitution [?0 := S2, ?1 := u32]"
+            "Unique; substitution [?0 := S2, ?1 := Uint(U32)]"
         }
     }
 }
@@ -276,7 +274,7 @@ fn projection_equality_priority2() {
         } yields[SolverChoice::recursive()] {
             // Constraining Out1 = S1 gives us only one choice, use the impl,
             // and the recursive solver prefers the normalized form.
-            "Unique; substitution [?0 := S1, ?1 := u32], lifetime constraints []"
+            "Unique; substitution [?0 := S1, ?1 := Uint(U32)], lifetime constraints []"
         }
     }
 }
@@ -301,7 +299,7 @@ fn projection_equality_from_env() {
             // this is wrong, chalk#234
             "Ambiguous"
         } yields[SolverChoice::recursive()] {
-            "Unique; substitution [?0 := u32]"
+            "Unique; substitution [?0 := Uint(U32)]"
         }
     }
 }
@@ -329,7 +327,7 @@ fn projection_equality_nested() {
             // this is wrong, chalk#234
             "Ambiguous"
         }  yields[SolverChoice::recursive()] {
-            "Unique; substitution [?0 := u32]"
+            "Unique; substitution [?0 := Uint(U32)]"
         }
     }
 }
@@ -371,7 +369,7 @@ fn iterator_flatten() {
             // this is wrong, chalk#234
             "Ambiguous"
         } yields[SolverChoice::recursive()] {
-            "Unique; substitution [?0 := u32]"
+            "Unique; substitution [?0 := Uint(U32)]"
         }
     }
 }

tests/test/scalars.rs

@@ -48,6 +48,7 @@ fn scalar_trait_impl() {
     test! {
         program {
             trait Foo { }
+            trait UnsignedFoo { }
 
             impl Foo for i8 { }
             impl Foo for i16 { }
@@ -65,6 +66,14 @@ fn scalar_trait_impl() {
             impl Foo for f64 { }
             impl Foo for bool { }
             impl Foo for char { }
+
+            impl UnsignedFoo for u8 { }
+            impl UnsignedFoo for u16 { }
+            impl UnsignedFoo for u32 { }
+            impl UnsignedFoo for u64 { }
+            impl UnsignedFoo for u128 { }
+            impl UnsignedFoo for usize { }
+
         }
 
         goal { i8: Foo } yields { "Unique" }
@@ -83,5 +92,23 @@ fn scalar_trait_impl() {
         goal { f64: Foo } yields { "Unique" }
         goal { bool: Foo } yields { "Unique" }
         goal { char: Foo } yields { "Unique" }
+
+        goal { i8: UnsignedFoo } yields { "No possible solution" }
+        goal { i16: UnsignedFoo } yields { "No possible solution" }
+        goal { i32: UnsignedFoo } yields { "No possible solution" }
+        goal { i64: UnsignedFoo } yields { "No possible solution" }
+        goal { i128: UnsignedFoo } yields { "No possible solution" }
+        goal { isize: UnsignedFoo } yields { "No possible solution" }
+        goal { u8: UnsignedFoo } yields { "Unique" }
+        goal { u16: UnsignedFoo } yields { "Unique" }
+        goal { u32: UnsignedFoo } yields { "Unique" }
+        goal { u64: UnsignedFoo } yields { "Unique" }
+        goal { u128: UnsignedFoo } yields { "Unique" }
+        goal { usize: UnsignedFoo } yields { "Unique" }
+        goal { f32: UnsignedFoo } yields { "No possible solution" }
+        goal { f64: UnsignedFoo } yields { "No possible solution" }
+        goal { bool: UnsignedFoo } yields { "No possible solution" }
+        goal { char: UnsignedFoo } yields { "No possible solution" }
+
     }
 }