Expand test

Author: Aaron1011

chalk-integration/src/lowering.rs

@@ -88,6 +88,7 @@ enum ApplyTypeLookup {
     Adt(AdtId<ChalkIr>),
     FnDef(FnDefId<ChalkIr>),
     Closure(ClosureId<ChalkIr>),
+    Generator(GeneratorId<ChalkIr>),
     Opaque(OpaqueTyId<ChalkIr>),
 }
 
@@ -220,6 +221,10 @@ impl<'k> Env<'k> {
             return Ok(ApplyTypeLookup::Closure(*id));
         }
 
+        if let Some(id) = self.generator_ids.get(&name.str) {
+            return Ok(ApplyTypeLookup::Generator(*id));
+        }
+
         if let Some(id) = self.opaque_ty_ids.get(&name.str) {
             return Ok(ApplyTypeLookup::Opaque(*id));
         }
@@ -1306,11 +1311,13 @@ impl LowerGeneratorDefn for GeneratorDefn {
             let yield_type = self.yield_ty.lower(env)?;
             let resume_type = self.resume_ty.lower(env)?;
             let return_type = self.return_ty.lower(env)?;
+            let upvars: LowerResult<_> = self.upvars.iter().map(|ty| ty.lower(env)).collect();
 
             Ok(rust_ir::GeneratorInputOutputDatum {
                 resume_type,
                 yield_type,
                 return_type,
+                upvars: upvars?
             })
         })?;
 
@@ -1326,31 +1333,6 @@ impl LowerGeneratorDefn for GeneratorDefn {
     }
 }
 
-trait LowerGeneratorInputOutputDatum {
-    fn lower_generator_input_output_datum(
-        &self,
-        env: &Env
-    ) -> LowerResult<chalk_ir::Binders<rust_ir::GeneratorInputOutputDatum<ChalkIr>>>;
-}
-
-impl LowerGeneratorInputOutputDatum for GeneratorDefn {
-    fn lower_generator_input_output_datum(
-        &self,
-        env: &Env
-    ) -> LowerResult<chalk_ir::Binders<rust_ir::GeneratorInputOutputDatum<ChalkIr>>> {
-        env.in_binders(self.all_parameters(), |env| {
-            let resume_type = self.resume_ty.lower(env)?;
-            let yield_type = self.yield_ty.lower(env)?;
-            let return_type = self.return_ty.lower(env)?;
-            Ok(rust_ir::GeneratorInputOutputDatum {
-                resume_type,
-                yield_type,
-                return_type
-            })
-        })
-    }
-}
-
 trait LowerClosureKind {
     fn lower_closure_kind(&self) -> LowerResult<rust_ir::ClosureKind>;
 }
@@ -1689,6 +1671,9 @@ impl LowerTy for Ty {
                     ApplyTypeLookup::FnDef(id) => {
                         (chalk_ir::TypeName::FnDef(id), env.fn_def_kind(id))
                     }
+                    ApplyTypeLookup::Generator(id) => {
+                        (chalk_ir::TypeName::Generator(id), env.generator_kind(id))
+                    }
                     ApplyTypeLookup::Closure(id) => {
                         (chalk_ir::TypeName::Closure(id), env.closure_kind(id))
                     }

chalk-ir/src/cast.rs

@@ -310,6 +310,15 @@ where
     }
 }
 
+impl<I> CastTo<TypeName<I>> for GeneratorId<I>
+    where
+        I: Interner,
+{
+    fn cast_to(self, _interner: &I) -> TypeName<I> {
+        TypeName::Generator(self)
+    }
+}
+
 impl<I> CastTo<TypeName<I>> for FnDefId<I>
 where
     I: Interner,

chalk-parse/src/ast.rs

@@ -44,6 +44,7 @@ pub struct StructDefn {
 pub struct GeneratorDefn {
     pub name: Identifier,
     pub variable_kinds: Vec<VariableKind>,
+    pub upvars: Vec<Ty>,
     pub resume_ty: Ty,
     pub yield_ty: Ty,
     pub return_ty: Ty,

chalk-parse/src/parser.lalrpop

@@ -108,6 +108,7 @@ GeneratorDefn: GeneratorDefn = {
     "}" => GeneratorDefn {
        name: n,
        variable_kinds: p,
+       upvars: upvars,
        witness_lifetimes: l.unwrap_or_default(),
        resume_ty: resume,
        yield_ty: yield_ty,

chalk-solve/src/clauses.rs

@@ -163,6 +163,55 @@ pub fn push_auto_trait_impls_opaque<I: Interner>(
     });
 }
 
+#[instrument(level = "debug", skip(builder))]
+pub fn push_auto_trait_impls_generator<I: Interner>(
+    builder: &mut ClauseBuilder<'_, I>,
+    auto_trait_id: TraitId<I>,
+    generator_id: GeneratorId<I>,
+) {
+    let generator_datum = builder.db.generator_datum(generator_id);
+    let interner = builder.interner();
+
+    // Must be an auto trait.
+    assert!(builder.db.trait_datum(auto_trait_id).is_auto_trait());
+
+    // Auto traits never have generic parameters of their own (apart from `Self`).
+    assert_eq!(
+        builder.db.trait_datum(auto_trait_id).binders.len(interner),
+        1
+    );
+
+    builder.push_binders(&generator_datum.input_output, |builder, input_output| {
+        let self_ty: Ty<_> = ApplicationTy {
+            name: generator_id.cast(interner),
+            substitution: builder.substitution_in_scope(),
+        }
+            .intern(interner);
+
+        // trait_ref = `Generator<...>: MyAutoTrait`
+        let auto_trait_ref = TraitRef {
+            trait_id: auto_trait_id,
+            substitution: Substitution::from1(interner, self_ty),
+        };
+
+        debug!("input output: {:?}", generator_datum.input_output);
+
+        // forall<P0..Pn> { // generic parameters from struct
+        //   MyStruct<...>: MyAutoTrait :-
+        //      Field0: MyAutoTrait,
+        //      ...
+        //      FieldN: MyAutoTrait
+        // }
+        builder.push_clause(
+            auto_trait_ref,
+            input_output.upvars.iter().map(|upvar_ty| TraitRef {
+                trait_id: auto_trait_id,
+                substitution: Substitution::from1(interner, upvar_ty.clone()),
+            }),
+        );
+    });
+}
+
 /// Given some goal `goal` that must be proven, along with
 /// its `environment`, figures out the program clauses that apply
 /// to this goal from the Rust program. So for example if the goal
@@ -249,6 +298,9 @@ fn program_clauses_that_could_match<I: Interner>(
                         TypeName::Adt(adt_id) => {
                             push_auto_trait_impls(builder, trait_id, *adt_id);
                         }
+                        TypeName::Generator(generator_id) => {
+                            push_auto_trait_impls_generator(builder, trait_id, *generator_id);
+                        }
                         _ => {}
                     },
                     TyData::InferenceVar(_, _) | TyData::BoundVar(_) => {

chalk-solve/src/rust_ir.rs

@@ -645,6 +645,7 @@ pub struct GeneratorInputOutputDatum<I: Interner> {
     pub resume_type: Ty<I>,
     pub yield_type: Ty<I>,
     pub return_type: Ty<I>,
+    pub upvars: Vec<Ty<I>>,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Fold, HasInterner)]

tests/test/generators.rs

@@ -4,14 +4,21 @@ use super::*;
 fn generator_is_well_formed() {
     test! {
         program {
+            #[auto] trait Send { }
+
+            struct StructOne {}
+            struct NotSend {}
+            impl !Send for NotSend {}
+            struct StructThree<'a> { val: &'a () }
+
             generator foo<>[resume = (), yield = ()] {
                 upvars []
                 witnesses []
             }
 
             generator bar<T>[resume = (), yield = ()] {
-                upvars [T; u8; i32]
-                witnesses for<'a> [&'a u8]
+                upvars [T; StructOne]
+                witnesses for<'a> [NotSend]
             }
         }
 
@@ -20,5 +27,29 @@ fn generator_is_well_formed() {
         } yields {
             "Unique"
         }
+
+        goal {
+            foo: Send
+        } yields {
+            "Unique"
+        }
+
+        goal {
+            forall<T> {
+                bar<T>: Send
+            }
+        } yields {
+            "No possible solution"
+        }
+
+        goal {
+            forall<T> {
+                if (T: Send) {
+                    bar<T>: Send
+                }
+            }
+        } yields {
+            "Unique"
+        }
     }
 }