Auto merge of #738 - nrc:well-known, r=nrc

Make DispatchFromDyn a well-known type

The first commit is some minor refactoring. The second commit does the 'obvious' work of making DispatchFromDyn well-known. In order to properly enforce the wf-ness constraints on DispatchFromDyn, Chalk needs to know about one-zst types, that is in the next commit. The final commit finishes the DispatchFromDyn work by enforcing the WF-ness constraints and adding tests.

r? `@jackh726`

Author: bors

chalk-integration/src/db.rs

@@ -13,9 +13,9 @@ use chalk_ir::{
     UnificationDatabase, Variances,
 };
 use chalk_solve::rust_ir::{
-    AdtDatum, AdtRepr, AssociatedTyDatum, AssociatedTyValue, AssociatedTyValueId, ClosureKind,
-    FnDefDatum, FnDefInputsAndOutputDatum, GeneratorDatum, GeneratorWitnessDatum, ImplDatum,
-    OpaqueTyDatum, TraitDatum, WellKnownTrait,
+    AdtDatum, AdtRepr, AdtSizeAlign, AssociatedTyDatum, AssociatedTyValue, AssociatedTyValueId,
+    ClosureKind, FnDefDatum, FnDefInputsAndOutputDatum, GeneratorDatum, GeneratorWitnessDatum,
+    ImplDatum, OpaqueTyDatum, TraitDatum, WellKnownTrait,
 };
 use chalk_solve::{RustIrDatabase, Solution, SubstitutionResult};
 use salsa::Database;
@@ -133,6 +133,10 @@ impl RustIrDatabase<ChalkIr> for ChalkDatabase {
         self.program_ir().unwrap().adt_repr(id)
     }
 
+    fn adt_size_align(&self, id: AdtId<ChalkIr>) -> Arc<AdtSizeAlign> {
+        self.program_ir().unwrap().adt_size_align(id)
+    }
+
     fn fn_def_datum(&self, id: FnDefId<ChalkIr>) -> Arc<FnDefDatum<ChalkIr>> {
         self.program_ir().unwrap().fn_def_datum(id)
     }

chalk-integration/src/lowering.rs

@@ -325,6 +325,10 @@ impl LowerWithEnv for (&AdtDefn, chalk_ir::AdtId<ChalkIr>) {
     }
 }
 
+pub fn lower_adt_size_align(flags: &AdtFlags) -> rust_ir::AdtSizeAlign {
+    rust_ir::AdtSizeAlign::from_one_zst(flags.one_zst)
+}
+
 impl LowerWithEnv for AdtRepr {
     type Lowered = rust_ir::AdtRepr<ChalkIr>;
 
@@ -1138,6 +1142,7 @@ impl Lower for WellKnownTrait {
             WellKnownTrait::CoerceUnsized => rust_ir::WellKnownTrait::CoerceUnsized,
             WellKnownTrait::DiscriminantKind => rust_ir::WellKnownTrait::DiscriminantKind,
             WellKnownTrait::Generator => rust_ir::WellKnownTrait::Generator,
+            WellKnownTrait::DispatchFromDyn => rust_ir::WellKnownTrait::DispatchFromDyn,
         }
     }
 }

chalk-integration/src/lowering/program_lowerer.rs

@@ -13,7 +13,7 @@ use std::collections::{BTreeMap, HashSet};
 use std::sync::Arc;
 use string_cache::DefaultAtom as Atom;
 
-use super::{env::*, Lower, LowerParameterMap, LowerWithEnv, FIXME_SELF};
+use super::{env::*, lower_adt_size_align, Lower, LowerParameterMap, LowerWithEnv, FIXME_SELF};
 use crate::error::RustIrError;
 use crate::program::Program as LoweredProgram;
 use crate::RawId;
@@ -143,6 +143,7 @@ impl ProgramLowerer {
     pub fn lower(self, program: &Program, raw_ids: &[RawId]) -> LowerResult<LoweredProgram> {
         let mut adt_data = BTreeMap::new();
         let mut adt_reprs = BTreeMap::new();
+        let mut adt_size_aligns = BTreeMap::new();
         let mut adt_variances = BTreeMap::new();
         let mut fn_def_data = BTreeMap::new();
         let mut fn_def_variances = BTreeMap::new();
@@ -186,6 +187,7 @@ impl ProgramLowerer {
                     let adt_id = AdtId(raw_id);
                     adt_data.insert(adt_id, Arc::new((d, adt_id).lower(&empty_env)?));
                     adt_reprs.insert(adt_id, Arc::new(d.repr.lower(&empty_env)?));
+                    adt_size_aligns.insert(adt_id, Arc::new(lower_adt_size_align(&d.flags)));
                     let n_params = d.all_parameters().len();
                     let variances = match d.variances.clone() {
                         Some(v) => {
@@ -480,6 +482,7 @@ impl ProgramLowerer {
             trait_kinds: self.trait_kinds,
             adt_data,
             adt_reprs,
+            adt_size_aligns,
             adt_variances,
             fn_def_data,
             fn_def_variances,

chalk-integration/src/program.rs

@@ -9,9 +9,9 @@ use chalk_ir::{
     Substitution, TraitId, Ty, TyKind, UintTy, Variances,
 };
 use chalk_solve::rust_ir::{
-    AdtDatum, AdtRepr, AssociatedTyDatum, AssociatedTyValue, AssociatedTyValueId, ClosureKind,
-    FnDefDatum, FnDefInputsAndOutputDatum, GeneratorDatum, GeneratorWitnessDatum, ImplDatum,
-    ImplType, OpaqueTyDatum, TraitDatum, WellKnownTrait,
+    AdtDatum, AdtRepr, AdtSizeAlign, AssociatedTyDatum, AssociatedTyValue, AssociatedTyValueId,
+    ClosureKind, FnDefDatum, FnDefInputsAndOutputDatum, GeneratorDatum, GeneratorWitnessDatum,
+    ImplDatum, ImplType, OpaqueTyDatum, TraitDatum, WellKnownTrait,
 };
 use chalk_solve::split::Split;
 use chalk_solve::RustIrDatabase;
@@ -61,6 +61,8 @@ pub struct Program {
 
     pub adt_reprs: BTreeMap<AdtId<ChalkIr>, Arc<AdtRepr<ChalkIr>>>,
 
+    pub adt_size_aligns: BTreeMap<AdtId<ChalkIr>, Arc<AdtSizeAlign>>,
+
     pub fn_def_data: BTreeMap<FnDefId<ChalkIr>, Arc<FnDefDatum<ChalkIr>>>,
 
     pub closure_inputs_and_output:
@@ -430,6 +432,10 @@ impl RustIrDatabase<ChalkIr> for Program {
         self.adt_reprs[&id].clone()
     }
 
+    fn adt_size_align(&self, id: AdtId<ChalkIr>) -> Arc<AdtSizeAlign> {
+        self.adt_size_aligns[&id].clone()
+    }
+
     fn fn_def_datum(&self, id: FnDefId<ChalkIr>) -> Arc<FnDefDatum<ChalkIr>> {
         self.fn_def_data[&id].clone()
     }

chalk-parse/src/ast.rs

@@ -74,6 +74,7 @@ pub struct AdtFlags {
     pub upstream: bool,
     pub fundamental: bool,
     pub phantom_data: bool,
+    pub one_zst: bool,
     pub kind: AdtKind,
 }
 
@@ -159,6 +160,7 @@ pub enum WellKnownTrait {
     CoerceUnsized,
     DiscriminantKind,
     Generator,
+    DispatchFromDyn,
 }
 
 #[derive(Clone, PartialEq, Eq, Debug)]

chalk-parse/src/parser.lalrpop

@@ -53,6 +53,7 @@ NonEnumerableKeyword: () = "#" "[" "non_enumerable" "]";
 CoinductiveKeyword: () = "#" "[" "coinductive" "]";
 ObjectSafeKeyword: () = "#" "[" "object_safe" "]";
 PhantomDataKeyword: () = "#" "[" "phantom_data" "]";
+OneZstKeyword: () = "#" "[" "one_zst" "]";
 
 WellKnownTrait: WellKnownTrait = {
      "#" "[" "lang" "(" "sized" ")" "]" => WellKnownTrait::Sized,
@@ -67,6 +68,7 @@ WellKnownTrait: WellKnownTrait = {
      "#" "[" "lang" "(" "coerce_unsized" ")" "]" => WellKnownTrait::CoerceUnsized,
      "#" "[" "lang" "(" "discriminant_kind" ")" "]" => WellKnownTrait::DiscriminantKind,
      "#" "[" "lang" "(" "generator" ")" "]" => WellKnownTrait::Generator,
+     "#" "[" "lang" "(" "dispatch_from_dyn" ")" "]" => WellKnownTrait::DispatchFromDyn,
 };
 
 AdtReprAttr: AdtReprAttr = {
@@ -90,7 +92,7 @@ ReprIntTy: Ty = {
 }
 
 AdtDefn: AdtDefn = {
-    <variances:Variances?> <upstream:UpstreamKeyword?> <fundamental:FundamentalKeyword?> <phantom_data:PhantomDataKeyword?> <repr:AdtReprAttr*>
+    <variances:Variances?> <upstream:UpstreamKeyword?> <fundamental:FundamentalKeyword?> <phantom_data:PhantomDataKeyword?> <one_zst:OneZstKeyword?> <repr:AdtReprAttr*>
         "enum" <n:Id><p:Angle<VariableKind>>
         <w:QuantifiedWhereClauses> "{" <v:Variants> "}" => AdtDefn
     {
@@ -102,6 +104,7 @@ AdtDefn: AdtDefn = {
             upstream: upstream.is_some(),
             fundamental: fundamental.is_some(),
             phantom_data: phantom_data.is_some(),
+            one_zst: one_zst.is_some(),
             kind: AdtKind::Enum,
         },
         repr: AdtRepr {
@@ -115,7 +118,7 @@ AdtDefn: AdtDefn = {
         },
         variances,
     },
-    <variances:Variances?> <upstream:UpstreamKeyword?> <fundamental:FundamentalKeyword?> <phantom_data:PhantomDataKeyword?> <repr:AdtReprAttr*>
+    <variances:Variances?> <upstream:UpstreamKeyword?> <fundamental:FundamentalKeyword?> <phantom_data:PhantomDataKeyword?> <one_zst:OneZstKeyword?> <repr:AdtReprAttr*>
         "struct" <n:Id><p:Angle<VariableKind>>
         <w:QuantifiedWhereClauses> "{" <f:Fields> "}" => AdtDefn
     {
@@ -134,6 +137,7 @@ AdtDefn: AdtDefn = {
             upstream: upstream.is_some(),
             fundamental: fundamental.is_some(),
             phantom_data: phantom_data.is_some(),
+            one_zst: one_zst.is_some(),
             kind: AdtKind::Struct,
         },
         repr: AdtRepr {

chalk-solve/src/clauses/builtin_traits.rs

@@ -28,8 +28,6 @@ pub fn add_builtin_program_clauses<I: Interner>(
         let ty = self_ty.kind(db.interner()).clone();
 
         match well_known {
-            // There are no builtin impls provided for the following traits:
-            WellKnownTrait::Unpin | WellKnownTrait::Drop | WellKnownTrait::CoerceUnsized => (),
             // Built-in traits are non-enumerable.
             _ if self_ty.is_general_var(db.interner(), binders) => return Err(Floundered),
             WellKnownTrait::Sized => {
@@ -52,6 +50,11 @@ pub fn add_builtin_program_clauses<I: Interner>(
             WellKnownTrait::Generator => {
                 generator::add_generator_program_clauses(db, builder, self_ty)?;
             }
+            // There are no builtin impls provided for the following traits:
+            WellKnownTrait::Unpin
+            | WellKnownTrait::Drop
+            | WellKnownTrait::CoerceUnsized
+            | WellKnownTrait::DispatchFromDyn => (),
         }
         Ok(())
     })

chalk-solve/src/display/items.rs

@@ -204,6 +204,7 @@ impl<I: Interner> RenderAsRust<I> for TraitDatum<I> {
                 WellKnownTrait::CoerceUnsized => "coerce_unsized",
                 WellKnownTrait::DiscriminantKind => "discriminant_kind",
                 WellKnownTrait::Generator => "generator",
+                WellKnownTrait::DispatchFromDyn => "dispatch_from_dyn",
             };
             writeln!(f, "#[lang({})]", name)?;
         }

chalk-solve/src/display/stub.rs

@@ -90,6 +90,10 @@ impl<I: Interner, DB: RustIrDatabase<I>> RustIrDatabase<I> for StubWrapper<'_, D
         self.db.adt_repr(id)
     }
 
+    fn adt_size_align(&self, id: chalk_ir::AdtId<I>) -> Arc<crate::rust_ir::AdtSizeAlign> {
+        self.db.adt_size_align(id)
+    }
+
     fn fn_def_datum(
         &self,
         fn_def_id: chalk_ir::FnDefId<I>,

chalk-solve/src/lib.rs

@@ -67,6 +67,9 @@ pub trait RustIrDatabase<I: Interner>: Debug {
     /// Returns the representation for the ADT definition with the given id.
     fn adt_repr(&self, id: AdtId<I>) -> Arc<AdtRepr<I>>;
 
+    /// Returns the siza and alignment of the ADT definition with the given id.
+    fn adt_size_align(&self, id: AdtId<I>) -> Arc<AdtSizeAlign>;
+
     /// Returns the datum for the fn definition with the given id.
     fn fn_def_datum(&self, fn_def_id: FnDefId<I>) -> Arc<FnDefDatum<I>>;