Add ObjectSafe goal and flag

Author: AzureMarker

chalk-integration/src/db.rs

@@ -156,4 +156,10 @@ impl RustIrDatabase<ChalkIr> for ChalkDatabase {
     fn interner(&self) -> &ChalkIr {
         &ChalkIr
     }
+
+    fn is_object_safe(&self, trait_id: TraitId<ChalkIr>) -> bool {
+        self.program_ir()
+            .unwrap()
+            .is_object_safe(trait_id)
+    }
 }

chalk-integration/src/lowering.rs

@@ -758,6 +758,9 @@ impl LowerDomainGoal for DomainGoal {
                 vec![chalk_ir::DomainGoal::DownstreamType(ty.lower(env)?)]
             }
             DomainGoal::Reveal => vec![chalk_ir::DomainGoal::Reveal(())],
+            DomainGoal::ObjectSafe { id } => {
+                vec![chalk_ir::DomainGoal::ObjectSafe(env.lookup_trait(id)?)]
+            }
         };
         Ok(goals)
     }
@@ -1016,6 +1019,7 @@ impl LowerTraitFlags for TraitFlags {
             fundamental: self.fundamental,
             non_enumerable: self.non_enumerable,
             coinductive: self.coinductive,
+            object_safe: self.object_safe,
         }
     }
 }

chalk-integration/src/program.rs

@@ -392,4 +392,8 @@ impl RustIrDatabase<ChalkIr> for Program {
     fn interner(&self) -> &ChalkIr {
         &ChalkIr
     }
+
+    fn is_object_safe(&self, trait_id: TraitId<ChalkIr>) -> bool {
+        self.trait_datum(trait_id).is_object_safe_trait()
+    }
 }

chalk-ir/src/debug.rs

@@ -628,6 +628,7 @@ impl<I: Interner> Debug for DomainGoal<I> {
             DomainGoal::Compatible(_) => write!(fmt, "Compatible"),
             DomainGoal::DownstreamType(n) => write!(fmt, "DownstreamType({:?})", n),
             DomainGoal::Reveal(_) => write!(fmt, "Reveal"),
+            DomainGoal::ObjectSafe(n) => write!(fmt, "ObjectSafe({:?})", n)
         }
     }
 }

chalk-ir/src/lib.rs

@@ -1088,6 +1088,9 @@ pub enum DomainGoal<I: Interner> {
     /// Used to activate the "reveal mode", in which opaque (`impl Trait`) types can be equated
     /// to their actual type.
     Reveal(()),
+
+    /// Used to indicate that a trait is object safe.
+    ObjectSafe(TraitId<I>),
 }
 
 pub type QuantifiedWhereClause<I> = Binders<WhereClause<I>>;

chalk-parse/src/ast.rs

@@ -68,6 +68,7 @@ pub struct TraitFlags {
     pub fundamental: bool,
     pub non_enumerable: bool,
     pub coinductive: bool,
+    pub object_safe: bool,
 }
 
 #[derive(Clone, PartialEq, Eq, Debug)]
@@ -315,6 +316,7 @@ pub enum DomainGoal {
     Compatible,
     DownstreamType { ty: Ty },
     Reveal,
+    ObjectSafe { id: Identifier }
 }
 
 #[derive(Clone, PartialEq, Eq, Debug)]

chalk-parse/src/parser.lalrpop

@@ -43,6 +43,7 @@ MarkerKeyword: () = "#" "[" "marker" "]";
 FundamentalKeyword: () = "#" "[" "fundamental" "]";
 NonEnumerableKeyword: () = "#" "[" "non_enumerable" "]";
 CoinductiveKeyword: () = "#" "[" "coinductive" "]";
+ObjectSafeKeyword: () = "#" "[" "object_safe" "]";
 
 WellKnownTrait: WellKnownTrait = {
      "#" "[" "lang" "(" "sized" ")" "]" => WellKnownTrait::SizedTrait,
@@ -67,7 +68,7 @@ StructDefn: StructDefn = {
 };
 
 TraitDefn: TraitDefn = {
-    <auto:AutoKeyword?> <marker:MarkerKeyword?> <upstream:UpstreamKeyword?> <fundamental:FundamentalKeyword?> <non_enumerable:NonEnumerableKeyword?> <coinductive:CoinductiveKeyword?> <well_known:WellKnownTrait?> "trait" <n:Id><p:Angle<ParameterKind>>
+    <auto:AutoKeyword?> <marker:MarkerKeyword?> <upstream:UpstreamKeyword?> <fundamental:FundamentalKeyword?> <non_enumerable:NonEnumerableKeyword?> <coinductive:CoinductiveKeyword?> <object_safe:ObjectSafeKeyword?> <well_known:WellKnownTrait?> "trait" <n:Id><p:Angle<ParameterKind>>
         <w:QuantifiedWhereClauses> "{" <a:AssocTyDefn*> "}" => TraitDefn
     {
         name: n,
@@ -82,6 +83,7 @@ TraitDefn: TraitDefn = {
             fundamental: fundamental.is_some(),
             non_enumerable: non_enumerable.is_some(),
             coinductive: coinductive.is_some(),
+            object_safe: object_safe.is_some(),
         },
     }
 };
@@ -365,6 +367,8 @@ DomainGoal: DomainGoal = {
     "DownstreamType" "(" <ty:Ty> ")" => DomainGoal::DownstreamType { ty },
 
     "Reveal" => DomainGoal::Reveal,
+
+    "ObjectSafe" "(" <id:Id> ")" => DomainGoal::ObjectSafe { id }
 };
 
 LeafGoal: LeafGoal = {

chalk-rust-ir/src/lib.rs

@@ -168,6 +168,10 @@ impl<I: Interner> TraitDatum<I> {
         self.flags.coinductive
     }
 
+    pub fn is_object_safe_trait(&self) -> bool {
+        self.flags.object_safe
+    }
+
     /// Gives access to the where clauses of the trait, quantified over the type parameters of the trait:
     ///
     /// ```ignore
@@ -221,6 +225,9 @@ pub struct TraitFlags {
     pub non_enumerable: bool,
 
     pub coinductive: bool,
+
+    /// Indicates that a trait is object safe
+    pub object_safe: bool,
 }
 
 /// An inline bound, e.g. `: Foo<K>` in `impl<K, T: Foo<K>> SomeType<T>`.

chalk-solve/src/clauses.rs

@@ -244,16 +244,17 @@ fn program_clauses_that_could_match<I: Interner>(
                 .opaque_ty_data(opaque_ty.opaque_ty_id)
                 .to_program_clauses(builder),
         },
-        DomainGoal::WellFormed(WellFormed::Trait(trait_predicate)) => {
-            db.trait_datum(trait_predicate.trait_id)
+        DomainGoal::WellFormed(WellFormed::Trait(trait_ref))
+        | DomainGoal::LocalImplAllowed(trait_ref) => {
+            db.trait_datum(trait_ref.trait_id)
                 .to_program_clauses(builder);
         }
+        DomainGoal::ObjectSafe(trait_id) => db.trait_datum(*trait_id).to_program_clauses(builder),
         DomainGoal::WellFormed(WellFormed::Ty(ty))
         | DomainGoal::IsUpstream(ty)
-        | DomainGoal::DownstreamType(ty) => match_ty(builder, environment, ty)?,
-        DomainGoal::IsFullyVisible(ty) | DomainGoal::IsLocal(ty) => {
-            match_ty(builder, environment, ty)?
-        }
+        | DomainGoal::DownstreamType(ty)
+        | DomainGoal::IsFullyVisible(ty)
+        | DomainGoal::IsLocal(ty) => match_ty(builder, environment, ty)?,
         DomainGoal::FromEnv(_) => (), // Computed in the environment
         DomainGoal::Normalize(Normalize { alias, ty: _ }) => match alias {
             AliasTy::Projection(proj) => {
@@ -291,11 +292,7 @@ fn program_clauses_that_could_match<I: Interner>(
             }
             AliasTy::Opaque(_) => (),
         },
-        DomainGoal::LocalImplAllowed(trait_ref) => db
-            .trait_datum(trait_ref.trait_id)
-            .to_program_clauses(builder),
-        DomainGoal::Compatible(()) => (),
-        DomainGoal::Reveal(()) => (),
+        DomainGoal::Compatible(()) | DomainGoal::Reveal(()) => (),
     };
 
     Ok(())

chalk-solve/src/clauses/program_clauses.rs

@@ -540,6 +540,11 @@ impl<I: Interner> ToProgramClauses<I> for TraitDatum<I> {
                 );
             }
 
+            // Object safety check
+            if builder.db.is_object_safe(trait_ref.trait_id) {
+                builder.push_fact(DomainGoal::ObjectSafe(trait_ref.trait_id));
+            }
+
             // Reverse implied bound rules: given (e.g.) `trait Foo: Bar + Baz`,
             // we create rules like:
             //