Add some extra work

Author: Aaron1011

chalk-solve/src/clauses.rs

@@ -183,10 +183,14 @@ pub fn push_auto_trait_impls_generator<I: Interner>(
 
     builder.push_binders(&generator_datum.input_output, |builder, input_output| {
         let self_ty: Ty<_> = ApplicationTy {
-            name: generator_id.cast(interner),
+            name: TypeName::Generator(generator_id),
             substitution: builder.substitution_in_scope(),
-        }
-            .intern(interner);
+        }.intern(interner);
+
+        let witness_ty = ApplicationTy {
+            name: TypeName::GeneratorWitness(generator_id),
+            substitution: builder.substitution_in_scope(),
+        }.intern(interner);
 
         // trait_ref = `Generator<...>: MyAutoTrait`
         let auto_trait_ref = TraitRef {
@@ -207,11 +211,62 @@ pub fn push_auto_trait_impls_generator<I: Interner>(
             input_output.upvars.iter().map(|upvar_ty| TraitRef {
                 trait_id: auto_trait_id,
                 substitution: Substitution::from1(interner, upvar_ty.clone()),
-            }),
+            }).chain(std::iter::once(TraitRef {
+                trait_id: auto_trait_id,
+                substitution: Substitution::from1(interner, witness_ty)
+            })),
         );
     });
 }
 
+#[instrument(level = "debug", skip(builder))]
+pub fn push_auto_trait_impls_generator_witness<I: Interner>(
+    builder: &mut ClauseBuilder<'_, I>,
+    auto_trait_id: TraitId<I>,
+    generator_id: GeneratorId<I>,
+) {
+    let witness_datum = builder.db.generator_witness_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(&witness_datum.inner_types, |builder, inner_types| {
+        let witness_ty = ApplicationTy {
+            name: TypeName::GeneratorWitness(generator_id),
+            substitution: builder.substitution_in_scope(),
+        }.intern(interner);
+
+        // trait_ref = `GeneratorWitness<...>: MyAutoTrait`
+        let auto_trait_ref = TraitRef {
+            trait_id: auto_trait_id,
+            substitution: Substitution::from1(interner, witness_ty),
+        };
+
+        builder.push_binders(&inner_types.types, |builder, types| {
+            // forall<P0..Pn> { // generic parameters from struct
+            //   MyStruct<...>: MyAutoTrait :-
+            //      Field0: MyAutoTrait,
+            //      ...
+            //      FieldN: MyAutoTrait
+            // }
+            builder.push_clause(
+                auto_trait_ref,
+                types.iter().map(|witness_ty| TraitRef {
+                    trait_id: auto_trait_id,
+                    substitution: Substitution::from1(interner, witness_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
@@ -301,6 +356,9 @@ fn program_clauses_that_could_match<I: Interner>(
                         TypeName::Generator(generator_id) => {
                             push_auto_trait_impls_generator(builder, trait_id, *generator_id);
                         }
+                        TypeName::GeneratorWitness(generator_id) => {
+                            push_auto_trait_impls_generator_witness(builder, trait_id, *generator_id);
+                        }
                         _ => {}
                     },
                     TyData::InferenceVar(_, _) | TyData::BoundVar(_) => {

tests/test/generators.rs

@@ -1,28 +1,52 @@
 use super::*;
 
 #[test]
+fn simple_impl() {
+    test! {
+        program {
+            #[auto] trait Send { }
+
+            struct Generic<'a, 'b, T> { val: &'a T, other: &'b T }
+            impl<'a, 'b, T> Send for Generic<'b, 'b, T> {}
+        }
+
+        goal {
+            forall<'a, 'b, T> {
+                Generic<'a, 'b, T>: Send
+            }
+        } yields {
+            "Unique; substitution [], lifetime constraints []"
+        }
+    }
+
+}
+
+//#[test]
 fn generator_is_well_formed() {
     test! {
         program {
             #[auto] trait Send { }
 
+
             struct StructOne {}
             struct NotSend {}
-            impl !Send for NotSend {}
-            struct StructThree<'a> { val: &'a () }
+            struct Generic<'a, 'b, T> { val: &'a T, other: &'b T }
+            impl<'a, 'b, T> Send for Generic<'b, 'b, T> {}
+            //impl !Send for NotSend {}
+            //struct StructThree<'a> { val: &'a () }
 
-            generator foo<>[resume = (), yield = ()] {
+            /*generator foo<>[resume = (), yield = ()] {
                 upvars []
                 witnesses []
-            }
+            }*/
 
             generator bar<T>[resume = (), yield = ()] {
-                upvars [T; StructOne]
-                witnesses for<'a> [NotSend]
+                upvars [/*T; StructOne*/]
+                witnesses for<'a, 'b> [Generic<'a, 'b, T>]
             }
         }
 
-        goal {
+        /*goal {
             WellFormed(foo)
         } yields {
             "Unique"
@@ -40,7 +64,7 @@ fn generator_is_well_formed() {
             }
         } yields {
             "No possible solution"
-        }
+        }*/
 
         goal {
             forall<T> {
@@ -49,7 +73,7 @@ fn generator_is_well_formed() {
                 }
             }
         } yields {
-            "Unique"
+            "Unique; substitution [], lifetime constraints []"
         }
     }
 }