add Movability to GeneratorDatum

Author: basil-cow

chalk-integration/src/lowering.rs

@@ -1236,3 +1236,13 @@ impl Lower for Safety {
         }
     }
 }
+
+impl Lower for Movability {
+    type Lowered = rust_ir::Movability;
+    fn lower(&self) -> Self::Lowered {
+        match self {
+            Movability::Static => rust_ir::Movability::Static,
+            Movability::Movable => rust_ir::Movability::Movable,
+        }
+    }
+}

chalk-integration/src/lowering/program_lowerer.rs

@@ -453,7 +453,10 @@ impl ProgramLowerer {
                         Ok(GeneratorWitnessExistential { types: witnesses })
                     })?;
 
-                    let generator_datum = GeneratorDatum { input_output };
+                    let generator_datum = GeneratorDatum {
+                        movability: defn.movability.lower(),
+                        input_output,
+                    };
                     let generator_witness = GeneratorWitnessDatum { inner_types };
 
                     let id = self.generator_ids[&defn.name.str];

chalk-parse/src/ast.rs

@@ -50,10 +50,16 @@ pub struct Variant {
     pub name: Identifier,
     pub fields: Vec<Field>,
 }
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum Movability {
+    Static,
+    Movable,
+}
 
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct GeneratorDefn {
     pub name: Identifier,
+    pub movability: Movability,
     pub variable_kinds: Vec<VariableKind>,
     pub upvars: Vec<Ty>,
     pub resume_ty: Ty,

chalk-parse/src/parser.lalrpop

@@ -192,13 +192,19 @@ FnDefn: FnDefn = {
     }
 };
 
+Movability: Movability = {
+    "static" => Movability::Static,
+     => Movability::Movable
+}
+
 GeneratorDefn: GeneratorDefn = {
-    "generator" <n:Id> <p:Angle<VariableKind>> "[" "resume" "=" <resume:Ty> "," "yield" "=" <yield_ty:Ty> "]" <ret_ty:FnReturn?>
+    "generator" <m:Movability> <n:Id> <p:Angle<VariableKind>> "[" "resume" "=" <resume:Ty> "," "yield" "=" <yield_ty:Ty> "]" <ret_ty:FnReturn?>
     "{"
        "upvars" "[" <upvars:SemiColon<Ty>> "]"
        "witnesses" <l:ExistsLifetimes?> "[" <witnesses:SemiColon<Ty>> "]"
     "}" => GeneratorDefn {
        name: n,
+       movability: m,
        variable_kinds: p,
        upvars: upvars,
        witness_lifetimes: l.unwrap_or_default(),

chalk-solve/src/clauses.rs

@@ -2,6 +2,7 @@ use self::builder::ClauseBuilder;
 use self::env_elaborator::elaborate_env_clauses;
 use self::program_clauses::ToProgramClauses;
 use crate::goal_builder::GoalBuilder;
+use crate::rust_ir::{Movability, WellKnownTrait};
 use crate::split::Split;
 use crate::RustIrDatabase;
 use chalk_ir::cast::{Cast, Caster};
@@ -149,12 +150,7 @@ pub fn push_auto_trait_impls<I: Interner>(
     match ty {
         // function-types implement auto traits unconditionally
         TyKind::Function(_) => {
-            let auto_trait_ref = TraitRef {
-                trait_id: auto_trait_id,
-                substitution: Substitution::from1(interner, ty.clone().intern(interner)),
-            };
-
-            builder.push_fact(auto_trait_ref);
+            builder.push_fact(consequence);
             Ok(())
         }
         TyKind::InferenceVar(_, _) | TyKind::BoundVar(_) => Err(Floundered),
@@ -173,6 +169,21 @@ pub fn push_auto_trait_impls<I: Interner>(
             });
             Ok(())
         }
+        TyKind::Generator(generator_id, _) => {
+            if Some(auto_trait_id) == builder.db.well_known_trait_id(WellKnownTrait::Unpin) {
+                match builder.db.generator_datum(*generator_id).movability {
+                    // immovable generators are never `Unpin`
+                    Movability::Static => (),
+                    // movable generators are always `Unpin`
+                    Movability::Movable => builder.push_fact(consequence),
+                }
+            } else {
+                // if trait is not `Unpin`, use regular auto trait clause
+                let conditions = constituent_types(builder.db, ty).into_iter().map(mk_ref);
+                builder.push_clause(consequence, conditions);
+            }
+            Ok(())
+        }
 
         TyKind::GeneratorWitness(generator_id, _) => {
             push_auto_trait_impls_generator_witness(builder, auto_trait_id, *generator_id);

chalk-solve/src/rust_ir.rs

@@ -638,12 +638,23 @@ pub struct OpaqueTyDatumBound<I: Interner> {
     pub where_clauses: Binders<Vec<QuantifiedWhereClause<I>>>,
 }
 
+// The movability of a generator: whether a generator contains self-references,
+// causing it to be !Unpin
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum Movability {
+    Static,
+    Movable,
+}
+chalk_ir::copy_fold!(Movability);
+
 /// Represents a generator type.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Fold, HasInterner)]
 pub struct GeneratorDatum<I: Interner> {
+    // Can the generator be moved (is Unpin or not)
+    pub movability: Movability,
     /// All of the nested types for this generator. The `Binder`
     /// represents the types and lifetimes that this generator is generic over -
-    /// this behaves in the same way as `AdtDatun.binders`
+    /// this behaves in the same way as `AdtDatum.binders`
     pub input_output: Binders<GeneratorInputOutputDatum<I>>,
 }