Merge pull request #523 from voidc/adt-repr

Add method to get repr data of an ADT to ChalkDatabase

Author: jackh726

chalk-integration/src/db.rs

@@ -12,8 +12,8 @@ use chalk_ir::{
     Substitution, TraitId, Ty, UCanonical,
 };
 use chalk_solve::rust_ir::{
-    AdtDatum, AssociatedTyDatum, AssociatedTyValue, AssociatedTyValueId, ClosureKind, FnDefDatum,
-    FnDefInputsAndOutputDatum, ImplDatum, OpaqueTyDatum, TraitDatum, WellKnownTrait,
+    AdtDatum, AdtRepr, AssociatedTyDatum, AssociatedTyValue, AssociatedTyValueId, ClosureKind,
+    FnDefDatum, FnDefInputsAndOutputDatum, ImplDatum, OpaqueTyDatum, TraitDatum, WellKnownTrait,
 };
 use chalk_solve::{RustIrDatabase, Solution, SolverChoice, SubstitutionResult};
 use salsa::Database;
@@ -109,6 +109,10 @@ impl RustIrDatabase<ChalkIr> for ChalkDatabase {
         self.program_ir().unwrap().adt_datum(id)
     }
 
+    fn adt_repr(&self, id: AdtId<ChalkIr>) -> AdtRepr {
+        self.program_ir().unwrap().adt_repr(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

@@ -412,6 +412,7 @@ impl LowerProgram for Program {
         }
 
         let mut adt_data = BTreeMap::new();
+        let mut adt_reprs = BTreeMap::new();
         let mut fn_def_data = BTreeMap::new();
         let mut closure_inputs_and_output = BTreeMap::new();
         let mut closure_closure_kind = BTreeMap::new();
@@ -446,6 +447,7 @@ impl LowerProgram for Program {
                 Item::StructDefn(ref d) => {
                     let adt_id = AdtId(raw_id);
                     adt_data.insert(adt_id, Arc::new(d.lower_adt(adt_id, &empty_env)?));
+                    adt_reprs.insert(adt_id, d.lower_adt_repr()?);
                 }
                 Item::FnDefn(ref defn) => {
                     let fn_def_id = FnDefId(raw_id);
@@ -639,6 +641,7 @@ impl LowerProgram for Program {
             fn_def_kinds,
             trait_kinds,
             adt_data,
+            adt_reprs,
             fn_def_data,
             closure_inputs_and_output,
             closure_closure_kind,
@@ -1121,6 +1124,19 @@ impl LowerAdtDefn for StructDefn {
     }
 }
 
+trait LowerAdtRepr {
+    fn lower_adt_repr(&self) -> LowerResult<rust_ir::AdtRepr>;
+}
+
+impl LowerAdtRepr for StructDefn {
+    fn lower_adt_repr(&self) -> LowerResult<rust_ir::AdtRepr> {
+        Ok(rust_ir::AdtRepr {
+            repr_c: self.repr.repr_c,
+            repr_packed: self.repr.repr_packed,
+        })
+    }
+}
+
 trait LowerFnDefn {
     fn lower_fn_def(
         &self,

chalk-integration/src/program.rs

@@ -8,8 +8,9 @@ use chalk_ir::{
     ProgramClauseImplication, ProgramClauses, ProjectionTy, Substitution, TraitId, Ty,
 };
 use chalk_solve::rust_ir::{
-    AdtDatum, AssociatedTyDatum, AssociatedTyValue, AssociatedTyValueId, ClosureKind, FnDefDatum,
-    FnDefInputsAndOutputDatum, ImplDatum, ImplType, OpaqueTyDatum, TraitDatum, WellKnownTrait,
+    AdtDatum, AdtRepr, AssociatedTyDatum, AssociatedTyValue, AssociatedTyValueId, ClosureKind,
+    FnDefDatum, FnDefInputsAndOutputDatum, ImplDatum, ImplType, OpaqueTyDatum, TraitDatum,
+    WellKnownTrait,
 };
 use chalk_solve::split::Split;
 use chalk_solve::RustIrDatabase;
@@ -44,6 +45,8 @@ pub struct Program {
     /// For each ADT:
     pub adt_data: BTreeMap<AdtId<ChalkIr>, Arc<AdtDatum<ChalkIr>>>,
 
+    pub adt_reprs: BTreeMap<AdtId<ChalkIr>, AdtRepr>,
+
     pub fn_def_data: BTreeMap<FnDefId<ChalkIr>, Arc<FnDefDatum<ChalkIr>>>,
 
     pub closure_inputs_and_output:
@@ -359,6 +362,10 @@ impl RustIrDatabase<ChalkIr> for Program {
         self.adt_data[&id].clone()
     }
 
+    fn adt_repr(&self, id: AdtId<ChalkIr>) -> AdtRepr {
+        self.adt_reprs[&id]
+    }
+
     fn fn_def_datum(&self, id: FnDefId<ChalkIr>) -> Arc<FnDefDatum<ChalkIr>> {
         self.fn_def_data[&id].clone()
     }

chalk-parse/src/ast.rs

@@ -36,6 +36,7 @@ pub struct StructDefn {
     pub where_clauses: Vec<QuantifiedWhereClause>,
     pub fields: Vec<Field>,
     pub flags: StructFlags,
+    pub repr: StructRepr,
 }
 
 #[derive(Clone, PartialEq, Eq, Debug)]
@@ -45,6 +46,12 @@ pub struct StructFlags {
     pub phantom_data: bool,
 }
 
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct StructRepr {
+    pub repr_c: bool,
+    pub repr_packed: bool,
+}
+
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct FnDefn {
     pub name: Identifier,

chalk-parse/src/parser.lalrpop

@@ -59,8 +59,10 @@ WellKnownTrait: WellKnownTrait = {
      "#" "[" "lang" "(" "unsize" ")" "]" => WellKnownTrait::Unsize,
 };
 
+StructRepr: Atom = "#" "[" "repr" "(" <name:Id> ")" "]" => name.str;
+
 StructDefn: StructDefn = {
-    <upstream:UpstreamKeyword?> <fundamental:FundamentalKeyword?> <phantom_data:PhantomDataKeyword?>
+    <upstream:UpstreamKeyword?> <fundamental:FundamentalKeyword?> <phantom_data:PhantomDataKeyword?> <repr:StructRepr*>
         "struct" <n:Id><p:Angle<VariableKind>>
         <w:QuantifiedWhereClauses> "{" <f:Fields> "}" => StructDefn
     {
@@ -73,6 +75,10 @@ StructDefn: StructDefn = {
             fundamental: fundamental.is_some(),
             phantom_data: phantom_data.is_some(),
         },
+        repr: StructRepr {
+            repr_c: repr.iter().any(|s| s == "C"),
+            repr_packed: repr.iter().any(|s| s == "packed"),
+        },
     }
 };
 

chalk-solve/src/lib.rs

@@ -39,6 +39,9 @@ pub trait RustIrDatabase<I: Interner>: Debug {
     /// Returns the datum for the impl with the given id.
     fn adt_datum(&self, adt_id: AdtId<I>) -> Arc<AdtDatum<I>>;
 
+    /// Returns the representation for the ADT definition with the given id.
+    fn adt_repr(&self, id: AdtId<I>) -> AdtRepr;
+
     fn fn_def_datum(&self, fn_def_id: FnDefId<I>) -> Arc<FnDefDatum<I>>;
 
     /// Returns the datum for the impl with the given id.

chalk-solve/src/rust_ir.rs

@@ -104,6 +104,12 @@ pub struct AdtFlags {
     pub phantom_data: bool,
 }
 
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct AdtRepr {
+    pub repr_c: bool,
+    pub repr_packed: bool,
+}
+
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 /// A rust intermediate represention (rust_ir) of a function definition/declaration.
 /// For example, in the following rust code:

tests/integration/panic.rs

@@ -129,6 +129,10 @@ impl RustIrDatabase<ChalkIr> for MockDatabase {
         unimplemented!()
     }
 
+    fn adt_repr(&self, id: AdtId<ChalkIr>) -> AdtRepr {
+        unimplemented!()
+    }
+
     fn fn_def_datum(&self, fn_def_id: FnDefId<ChalkIr>) -> Arc<FnDefDatum<ChalkIr>> {
         unimplemented!()
     }

tests/lowering/mod.rs

@@ -737,3 +737,20 @@ fn closures() {
         }
     }
 }
+
+#[test]
+fn struct_repr() {
+    lowering_success! {
+        program {
+            #[repr(C)]
+            struct Foo {}
+
+            #[repr(packed)]
+            struct Bar {}
+
+            #[repr(C)]
+            #[repr(packed)]
+            struct FooBar {}
+        }
+    }
+}