Merge pull request #464 from nathanwhit/opaque-ty-generics

Opaque Type Generics

Author: detrumi

chalk-integration/src/lowering.rs

@@ -25,6 +25,7 @@ type OpaqueTyIds = BTreeMap<Ident, chalk_ir::OpaqueTyId<ChalkIr>>;
 type AdtKinds = BTreeMap<chalk_ir::AdtId<ChalkIr>, TypeKind>;
 type FnDefKinds = BTreeMap<chalk_ir::FnDefId<ChalkIr>, TypeKind>;
 type TraitKinds = BTreeMap<chalk_ir::TraitId<ChalkIr>, TypeKind>;
+type OpaqueTyKinds = BTreeMap<chalk_ir::OpaqueTyId<ChalkIr>, TypeKind>;
 type AssociatedTyLookups = BTreeMap<(chalk_ir::TraitId<ChalkIr>, Ident), AssociatedTyLookup>;
 type AssociatedTyValueIds =
     BTreeMap<(chalk_ir::ImplId<ChalkIr>, Ident), AssociatedTyValueId<ChalkIr>>;
@@ -42,6 +43,7 @@ struct Env<'k> {
     trait_ids: &'k TraitIds,
     trait_kinds: &'k TraitKinds,
     opaque_ty_ids: &'k OpaqueTyIds,
+    opaque_ty_kinds: &'k OpaqueTyKinds,
     associated_ty_lookups: &'k AssociatedTyLookups,
     /// GenericArg identifiers are used as keys, therefore
     /// all identifiers in an environment must be unique (no shadowing).
@@ -76,6 +78,7 @@ struct AssociatedTyLookup {
 enum ApplyTypeLookup {
     Adt(AdtId<ChalkIr>),
     FnDef(FnDefId<ChalkIr>),
+    Opaque(OpaqueTyId<ChalkIr>),
 }
 
 const SELF: &str = "Self";
@@ -158,10 +161,6 @@ impl<'k> Env<'k> {
             return Err(RustIrError::CannotApplyTypeParameter(name.clone()));
         }
 
-        if let Some(_) = self.opaque_ty_ids.get(&name.str) {
-            return Err(RustIrError::CannotApplyTypeParameter(name.clone()));
-        }
-
         if let Some(id) = self.adt_ids.get(&name.str) {
             return Ok(ApplyTypeLookup::Adt(*id));
         }
@@ -170,6 +169,10 @@ impl<'k> Env<'k> {
             return Ok(ApplyTypeLookup::FnDef(*id));
         }
 
+        if let Some(id) = self.opaque_ty_ids.get(&name.str) {
+            return Ok(ApplyTypeLookup::Opaque(*id));
+        }
+
         Err(RustIrError::NotStruct(name.clone()))
     }
 
@@ -201,6 +204,10 @@ impl<'k> Env<'k> {
         &self.fn_def_kinds[&id]
     }
 
+    fn opaque_kind(&self, id: chalk_ir::OpaqueTyId<ChalkIr>) -> &TypeKind {
+        &self.opaque_ty_kinds[&id]
+    }
+
     /// Introduces new parameters, shifting the indices of existing
     /// parameters to accommodate them. The indices of the new binders
     /// will be assigned in order as they are iterated.
@@ -369,6 +376,7 @@ impl LowerProgram for Program {
                 trait_ids: &trait_ids,
                 trait_kinds: &trait_kinds,
                 opaque_ty_ids: &opaque_ty_ids,
+                opaque_ty_kinds: &opaque_ty_kinds,
                 associated_ty_lookups: &associated_ty_lookups,
                 parameter_map: BTreeMap::new(),
             };
@@ -1311,6 +1319,9 @@ impl LowerTy for Ty {
                     ApplyTypeLookup::FnDef(id) => {
                         (chalk_ir::TypeName::FnDef(id), env.fn_def_kind(id))
                     }
+                    ApplyTypeLookup::Opaque(id) => {
+                        (chalk_ir::TypeName::OpaqueType(id), env.opaque_kind(id))
+                    }
                 };
 
                 if k.binders.len(interner) != args.len() {
@@ -1658,6 +1669,7 @@ impl LowerGoal<LoweredProgram> for Goal {
             adt_kinds: &program.adt_kinds,
             fn_def_kinds: &program.fn_def_kinds,
             trait_kinds: &program.trait_kinds,
+            opaque_ty_kinds: &program.opaque_ty_kinds,
             associated_ty_lookups: &associated_ty_lookups,
             parameter_map: BTreeMap::new(),
         };

chalk-solve/src/clauses.rs

@@ -229,9 +229,22 @@ fn program_clauses_that_could_match<I: Interner>(
             }
         }
         DomainGoal::Holds(WhereClause::AliasEq(alias_eq)) => match &alias_eq.alias {
-            AliasTy::Projection(proj) => db
-                .associated_ty_data(proj.associated_ty_id)
-                .to_program_clauses(builder),
+            AliasTy::Projection(proj) => {
+                let trait_self_ty = db
+                    .trait_ref_from_projection(proj)
+                    .self_type_parameter(interner);
+
+                if let TyData::Apply(ApplicationTy {
+                    name: TypeName::OpaqueType(opaque_ty_id),
+                    ..
+                }) = trait_self_ty.data(interner)
+                {
+                    db.opaque_ty_data(*opaque_ty_id).to_program_clauses(builder)
+                }
+
+                db.associated_ty_data(proj.associated_ty_id)
+                    .to_program_clauses(builder)
+            }
             AliasTy::Opaque(opaque_ty) => db
                 .opaque_ty_data(opaque_ty.opaque_ty_id)
                 .to_program_clauses(builder),

tests/test/existential_types.rs

@@ -2,52 +2,6 @@
 
 use super::*;
 
-#[test]
-fn opaque_bounds() {
-    test! {
-        program {
-            struct Ty { }
-
-            trait Clone { }
-            opaque type T: Clone = Ty;
-        }
-
-        goal {
-            T: Clone
-        } yields {
-            "Unique; substitution []"
-        }
-    }
-}
-
-#[test]
-fn opaque_reveal() {
-    test! {
-        program {
-            struct Ty { }
-            trait Trait { }
-            impl Trait for Ty { }
-
-            trait Clone { }
-            opaque type T: Clone = Ty;
-        }
-
-        goal {
-            if (Reveal) {
-                T: Trait
-            }
-        } yields {
-            "Unique; substitution []"
-        }
-
-        goal {
-            T: Trait
-        } yields {
-            "No possible solution"
-        }
-    }
-}
-
 #[test]
 fn dyn_Clone_is_Clone() {
     test! {

tests/test/mod.rs

@@ -308,6 +308,7 @@ mod impls;
 mod misc;
 mod negation;
 mod object_safe;
+mod opaque_types;
 mod projection;
 mod refs;
 mod scalars;

tests/test/opaque_types.rs

@@ -0,0 +1,100 @@
+use super::*;
+
+#[test]
+fn opaque_bounds() {
+    test! {
+        program {
+            struct Ty { }
+
+            trait Clone { }
+            opaque type T: Clone = Ty;
+        }
+
+        goal {
+            T: Clone
+        } yields {
+            "Unique; substitution []"
+        }
+    }
+}
+
+#[test]
+fn opaque_reveal() {
+    test! {
+        program {
+            struct Ty { }
+            trait Trait { }
+            impl Trait for Ty { }
+
+            trait Clone { }
+            opaque type T: Clone = Ty;
+        }
+
+        goal {
+            if (Reveal) {
+                T: Trait
+            }
+        } yields {
+            "Unique; substitution []"
+        }
+
+        goal {
+            T: Trait
+        } yields {
+            "No possible solution"
+        }
+    }
+}
+
+#[test]
+fn opaque_generics_simple() {
+    test! {
+        program {
+            trait Iterator { type Item; }
+
+            struct Vec<T> { }
+            struct Bar { }
+            impl<T> Iterator for Vec<T> {
+                type Item = u32;
+            }
+
+            opaque type Foo<X>: Iterator = Vec<X>;
+        }
+
+        goal {
+            Foo<Bar>: Iterator
+        } yields {
+            "Unique; substitution []"
+        }
+
+    }
+}
+
+#[test]
+fn opaque_generics() {
+    test! {
+        program {
+            trait Iterator { type Item; }
+
+            struct Vec<T> { }
+            struct Bar { }
+
+            opaque type Foo<X>: Iterator<Item = X> = Vec<X>;
+        }
+
+        goal {
+            Foo<Bar>: Iterator<Item = Bar>
+        } yields {
+            "Unique; substitution []"
+        }
+
+        goal {
+            forall<T> {
+                Foo<T>: Iterator<Item = T>
+            }
+        } yields {
+            "Unique; substitution []"
+        }
+
+    }
+}