create VariantDef-s (but don't actually use them)

Author: Ariel Ben-Yehuda

src/librustc/metadata/csearch.rs

@@ -222,10 +222,10 @@ pub fn get_trait_def<'tcx>(tcx: &ty::ctxt<'tcx>, def: ast::DefId) -> ty::TraitDe
     decoder::get_trait_def(&*cdata, def.node, tcx)
 }
 
-pub fn get_adt_def<'tcx>(tcx: &ty::ctxt<'tcx>, def: ast::DefId) -> &'tcx ty::ADTDef<'tcx> {
+pub fn get_adt_def<'tcx>(tcx: &ty::ctxt<'tcx>, def: ast::DefId) -> &'tcx ty::ADTDef_<'tcx, 'tcx> {
     let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
-    decoder::get_adt_def(&*cdata, def.node, tcx)
+    decoder::get_adt_def(&cstore.intr, &*cdata, def.node, tcx)
 }
 
 pub fn get_predicates<'tcx>(tcx: &ty::ctxt<'tcx>, def: ast::DefId)

src/librustc/metadata/decoder.rs

@@ -108,7 +108,7 @@ fn lookup_item<'a>(item_id: ast::NodeId, data: &'a [u8]) -> rbml::Doc<'a> {
     find_item(item_id, items)
 }
 
-#[derive(PartialEq)]
+#[derive(Debug, PartialEq)]
 enum Family {
     ImmStatic,             // c
     MutStatic,             // b
@@ -390,12 +390,111 @@ pub fn get_trait_def<'tcx>(cdata: Cmd,
     }
 }
 
-pub fn get_adt_def<'tcx>(cdata: Cmd,
+pub fn get_adt_def<'tcx>(intr: &IdentInterner,
+                         cdata: Cmd,
                          item_id: ast::NodeId,
-                         tcx: &ty::ctxt<'tcx>) -> &'tcx ty::ADTDef<'tcx>
+                         tcx: &ty::ctxt<'tcx>) -> &'tcx ty::ADTDef_<'tcx, 'tcx>
 {
-    tcx.intern_adt_def(ast::DefId { krate: cdata.cnum, node: item_id },
-                       ty::ADTKind::Enum)
+    fn get_enum_variants<'tcx>(intr: &IdentInterner,
+                               cdata: Cmd,
+                               doc: rbml::Doc,
+                               tcx: &ty::ctxt<'tcx>) -> Vec<ty::VariantDef_<'tcx, 'tcx>> {
+        let mut disr_val = 0;
+        reader::tagged_docs(doc, tag_items_data_item_variant).map(|p| {
+            let did = translated_def_id(cdata, p);
+            let item = lookup_item(did.node, cdata.data());
+
+            if let Some(disr) = variant_disr_val(item) {
+                disr_val = disr;
+            }
+            let disr = disr_val;
+            disr_val = disr_val.wrapping_add(1);
+
+            ty::VariantDef_ {
+                did: did,
+                name: item_name(intr, item),
+                fields: get_variant_fields(intr, cdata, item, tcx),
+                disr_val: disr
+            }
+        }).collect()
+    }
+    fn get_variant_fields<'tcx>(intr: &IdentInterner,
+                                cdata: Cmd,
+                                doc: rbml::Doc,
+                                tcx: &ty::ctxt<'tcx>) -> Vec<ty::FieldDef_<'tcx, 'tcx>> {
+        reader::tagged_docs(doc, tag_item_field).map(|f| {
+            let ff = item_family(f);
+            match ff {
+                PublicField | InheritedField => {},
+                _ => tcx.sess.bug(&format!("expected field, found {:?}", ff))
+            };
+            ty::FieldDef_::new(item_def_id(f, cdata),
+                               item_name(intr, f),
+                               struct_field_family_to_visibility(ff))
+        }).chain(reader::tagged_docs(doc, tag_item_unnamed_field).map(|f| {
+            let ff = item_family(f);
+            ty::FieldDef_::new(item_def_id(f, cdata),
+                               special_idents::unnamed_field.name,
+                               struct_field_family_to_visibility(ff))
+        })).collect()
+    }
+    fn get_struct_variant<'tcx>(intr: &IdentInterner,
+                                cdata: Cmd,
+                                doc: rbml::Doc,
+                                did: ast::DefId,
+                                tcx: &ty::ctxt<'tcx>) -> ty::VariantDef_<'tcx, 'tcx> {
+        ty::VariantDef_ {
+            did: did,
+            name: item_name(intr, doc),
+            fields: get_variant_fields(intr, cdata, doc, tcx),
+            disr_val: 0
+        }
+    }
+
+    let doc = lookup_item(item_id, cdata.data());
+    let did = ast::DefId { krate: cdata.cnum, node: item_id };
+    let (kind, variants) = match item_family(doc) {
+        Enum => (ty::ADTKind::Enum,
+                 get_enum_variants(intr, cdata, doc, tcx)),
+        Struct => (ty::ADTKind::Struct,
+                   vec![get_struct_variant(intr, cdata, doc, did, tcx)]),
+        _ => tcx.sess.bug("get_adt_def called on a non-ADT")
+    };
+
+    let adt = tcx.intern_adt_def(did, kind, variants);
+
+    // this needs to be done *after* the variant is interned,
+    // to support recursive structures
+    for variant in &adt.variants {
+        if variant.kind() == ty::VariantKind::Tuple &&
+            adt.adt_kind() == ty::ADTKind::Enum {
+            // tuple-like enum variant fields aren't real items - get the types
+            // from the ctor.
+            debug!("evaluating the ctor-type of {:?}",
+                   variant.name);
+            let ctor_ty = get_type(cdata, variant.did.node, tcx).ty;
+            debug!("evaluating the ctor-type of {:?}.. {:?}",
+                   variant.name,
+                   ctor_ty);
+            let field_tys = match ctor_ty.sty {
+                ty::TyBareFn(_, ref f) => &f.sig.skip_binder().inputs,
+                _ => tcx.sess.bug("tuple-variant ctor is not an ADT")
+            };
+            for (field, &ty) in variant.fields.iter().zip(field_tys.iter()) {
+                field.fulfill_ty(ty);
+            }
+        } else {
+            for field in &variant.fields {
+                debug!("evaluating the type of {:?}::{:?}", variant.name, field.name);
+                let ty = get_type(cdata, field.did.node, tcx).ty;
+                field.fulfill_ty(ty);
+                debug!("evaluating the type of {:?}::{:?}: {:?}",
+                       variant.name, field.name, ty);
+            }
+        }
+    }
+
+    adt
 }
 
 pub fn get_predicates<'tcx>(cdata: Cmd,

src/librustc/metadata/encoder.rs

@@ -41,7 +41,6 @@ use syntax::attr::AttrMetaMethods;
 use syntax::diagnostic::SpanHandler;
 use syntax::parse::token::special_idents;
 use syntax::print::pprust;
-use syntax::ptr::P;
 use syntax::visit::Visitor;
 use syntax::visit;
 use syntax;
@@ -266,7 +265,7 @@ fn encode_parent_item(rbml_w: &mut Encoder, id: DefId) {
 }
 
 fn encode_struct_fields(rbml_w: &mut Encoder,
-                        fields: &[ty::FieldTy],
+                        fields: &[ty::FieldDef],
                         origin: DefId) {
     for f in fields {
         if f.name == special_idents::unnamed_field.name {
@@ -276,7 +275,7 @@ fn encode_struct_fields(rbml_w: &mut Encoder,
             encode_name(rbml_w, f.name);
         }
         encode_struct_field_family(rbml_w, f.vis);
-        encode_def_id(rbml_w, f.id);
+        encode_def_id(rbml_w, f.did);
         rbml_w.wr_tagged_u64(tag_item_field_origin, def_to_u64(origin));
         rbml_w.end_tag();
     }
@@ -285,57 +284,56 @@ fn encode_struct_fields(rbml_w: &mut Encoder,
 fn encode_enum_variant_info(ecx: &EncodeContext,
                             rbml_w: &mut Encoder,
                             id: NodeId,
-                            variants: &[P<ast::Variant>],
+                            vis: ast::Visibility,
                             index: &mut Vec<entry<i64>>) {
     debug!("encode_enum_variant_info(id={})", id);
 
     let mut disr_val = 0;
-    let mut i = 0;
-    let vi = ecx.tcx.enum_variants(local_def(id));
-    for variant in variants {
-        let def_id = local_def(variant.node.id);
+    let def = ecx.tcx.lookup_adt_def(local_def(id));
+    for variant in &def.variants {
+        let vid = variant.did;
+        assert!(is_local(vid));
         index.push(entry {
-            val: variant.node.id as i64,
+            val: vid.node as i64,
             pos: rbml_w.mark_stable_position(),
         });
         rbml_w.start_tag(tag_items_data_item);
-        encode_def_id(rbml_w, def_id);
-        match variant.node.kind {
-            ast::TupleVariantKind(_) => encode_family(rbml_w, 'v'),
-            ast::StructVariantKind(_) => encode_family(rbml_w, 'V')
-        }
-        encode_name(rbml_w, variant.node.name.name);
+        encode_def_id(rbml_w, vid);
+        encode_family(rbml_w, match variant.kind() {
+            ty::VariantKind::Unit | ty::VariantKind::Tuple => 'v',
+            ty::VariantKind::Dict => 'V'
+        });
+        encode_name(rbml_w, variant.name);
         encode_parent_item(rbml_w, local_def(id));
-        encode_visibility(rbml_w, variant.node.vis);
-        encode_attributes(rbml_w, &variant.node.attrs);
-        encode_repr_attrs(rbml_w, ecx, &variant.node.attrs);
+        encode_visibility(rbml_w, vis);
+
+        let attrs = ecx.tcx.get_attrs(vid);
+        encode_attributes(rbml_w, &attrs);
+        encode_repr_attrs(rbml_w, ecx, &attrs);
 
-        let stab = stability::lookup(ecx.tcx, ast_util::local_def(variant.node.id));
+        let stab = stability::lookup(ecx.tcx, vid);
         encode_stability(rbml_w, stab);
 
-        match variant.node.kind {
-            ast::TupleVariantKind(_) => {},
-            ast::StructVariantKind(_) => {
-                let fields = ecx.tcx.lookup_struct_fields(def_id);
-                let idx = encode_info_for_struct(ecx,
-                                                 rbml_w,
-                                                 &fields[..],
-                                                 index);
-                encode_struct_fields(rbml_w, &fields[..], def_id);
-                encode_index(rbml_w, idx, write_i64);
-            }
+        if let ty::VariantKind::Dict = variant.kind() {
+            let idx = encode_info_for_struct(ecx,
+                                             rbml_w,
+                                             &variant.fields,
+                                             index);
+            encode_index(rbml_w, idx, write_i64);
         }
-        let specified_disr_val = vi[i].disr_val;
+
+        encode_struct_fields(rbml_w, &variant.fields, vid);
+
+        let specified_disr_val = variant.disr_val;
         if specified_disr_val != disr_val {
             encode_disr_val(ecx, rbml_w, specified_disr_val);
             disr_val = specified_disr_val;
         }
-        encode_bounds_and_type_for_item(rbml_w, ecx, def_id.local_id());
+        encode_bounds_and_type_for_item(rbml_w, ecx, vid.node);
 
-        ecx.tcx.map.with_path(variant.node.id, |path| encode_path(rbml_w, path));
+        ecx.tcx.map.with_path(vid.node, |path| encode_path(rbml_w, path));
         rbml_w.end_tag();
         disr_val = disr_val.wrapping_add(1);
-        i += 1;
     }
 }
 
@@ -630,19 +628,19 @@ fn encode_provided_source(rbml_w: &mut Encoder,
 }
 
 /* Returns an index of items in this class */
-fn encode_info_for_struct(ecx: &EncodeContext,
-                          rbml_w: &mut Encoder,
-                          fields: &[ty::FieldTy],
-                          global_index: &mut Vec<entry<i64>>)
-                          -> Vec<entry<i64>> {
+fn encode_info_for_struct<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>,
+                                    rbml_w: &mut Encoder,
+                                    fields: &[ty::FieldDef<'tcx>],
+                                    global_index: &mut Vec<entry<i64>>)
+                                    -> Vec<entry<i64>> {
     /* Each class has its own index, since different classes
        may have fields with the same name */
     let mut index = Vec::new();
      /* We encode both private and public fields -- need to include
         private fields to get the offsets right */
     for field in fields {
         let nm = field.name;
-        let id = field.id.node;
+        let id = field.did.node;
 
         let pos = rbml_w.mark_stable_position();
         index.push(entry {val: id as i64, pos: pos});
@@ -658,7 +656,7 @@ fn encode_info_for_struct(ecx: &EncodeContext,
         encode_bounds_and_type_for_item(rbml_w, ecx, id);
         encode_def_id(rbml_w, local_def(id));
 
-        let stab = stability::lookup(ecx.tcx, field.id);
+        let stab = stability::lookup(ecx.tcx, field.did);
         encode_stability(rbml_w, stab);
 
         rbml_w.end_tag();
@@ -1150,20 +1148,18 @@ fn encode_info_for_item(ecx: &EncodeContext,
         encode_enum_variant_info(ecx,
                                  rbml_w,
                                  item.id,
-                                 &(*enum_definition).variants,
+                                 vis,
                                  index);
       }
       ast::ItemStruct(ref struct_def, _) => {
-        let fields = tcx.lookup_struct_fields(def_id);
+        let def = ecx.tcx.lookup_adt_def(def_id);
+        let fields = &def.struct_variant().fields;
 
         /* First, encode the fields
            These come first because we need to write them to make
            the index, and the index needs to be in the item for the
            class itself */
-        let idx = encode_info_for_struct(ecx,
-                                         rbml_w,
-                                         &fields[..],
-                                         index);
+        let idx = encode_info_for_struct(ecx, rbml_w, &fields, index);
 
         /* Index the class*/
         add_to_index(item, rbml_w, index);
@@ -1185,7 +1181,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
         /* Encode def_ids for each field and method
          for methods, write all the stuff get_trait_method
         needs to know*/
-        encode_struct_fields(rbml_w, &fields[..], def_id);
+        encode_struct_fields(rbml_w, &fields, def_id);
 
         encode_inlined_item(ecx, rbml_w, IIItemRef(item));
 

src/librustc/middle/check_match.rs

@@ -513,7 +513,7 @@ fn construct_witness<'a,'tcx>(cx: &MatchCheckCtxt<'a,'tcx>, ctor: &Constructor,
                 &Variant(vid) =>
                     (vid, cx.tcx.enum_variant_with_id(cid.did, vid).arg_names.is_some()),
                 _ =>
-                    (cid.did, !cid.is_tuple_struct(cx.tcx))
+                    (cid.did, !cid.struct_variant().is_tuple_struct())
             };
             if is_structure {
                 let fields = cx.tcx.lookup_struct_fields(vid);