introduce an ADTDef struct for struct/enum definitions

Author: Ariel Ben-Yehuda

src/librustc/metadata/csearch.rs

@@ -222,6 +222,12 @@ 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> {
+    let cstore = &tcx.sess.cstore;
+    let cdata = cstore.get_crate_data(def.krate);
+    decoder::get_adt_def(&*cdata, def.node, tcx)
+}
+
 pub fn get_predicates<'tcx>(tcx: &ty::ctxt<'tcx>, def: ast::DefId)
                             -> ty::GenericPredicates<'tcx>
 {

src/librustc/metadata/decoder.rs

@@ -390,6 +390,13 @@ pub fn get_trait_def<'tcx>(cdata: Cmd,
     }
 }
 
+pub fn get_adt_def<'tcx>(cdata: Cmd,
+                         item_id: ast::NodeId,
+                         tcx: &ty::ctxt<'tcx>) -> &'tcx ty::ADTDef<'tcx>
+{
+    tcx.intern_adt_def(ast::DefId { krate: cdata.cnum, node: item_id })
+}
+
 pub fn get_predicates<'tcx>(cdata: Cmd,
                             item_id: ast::NodeId,
                             tcx: &ty::ctxt<'tcx>)

src/librustc/metadata/tydecode.rs

@@ -468,9 +468,10 @@ fn parse_ty_<'a, 'tcx, F>(st: &mut PState<'a, 'tcx>, conv: &mut F) -> Ty<'tcx> w
       'c' => return tcx.types.char,
       't' => {
         assert_eq!(next(st), '[');
-        let def = parse_def_(st, NominalType, conv);
+        let did = parse_def_(st, NominalType, conv);
         let substs = parse_substs_(st, conv);
         assert_eq!(next(st), ']');
+        let def = st.tcx.lookup_adt_def(did);
         return tcx.mk_enum(def, st.tcx.mk_substs(substs));
       }
       'x' => {
@@ -558,7 +559,8 @@ fn parse_ty_<'a, 'tcx, F>(st: &mut PState<'a, 'tcx>, conv: &mut F) -> Ty<'tcx> w
           let did = parse_def_(st, NominalType, conv);
           let substs = parse_substs_(st, conv);
           assert_eq!(next(st), ']');
-          return st.tcx.mk_struct(did, st.tcx.mk_substs(substs));
+          let def = st.tcx.lookup_adt_def(did);
+          return st.tcx.mk_struct(def, st.tcx.mk_substs(substs));
       }
       'k' => {
           assert_eq!(next(st), '[');

src/librustc/metadata/tyencode.rs

@@ -86,7 +86,7 @@ pub fn enc_ty<'a, 'tcx>(w: &mut Encoder, cx: &ctxt<'a, 'tcx>, t: Ty<'tcx>) {
             }
         }
         ty::TyEnum(def, substs) => {
-            mywrite!(w, "t[{}|", (cx.ds)(def));
+            mywrite!(w, "t[{}|", (cx.ds)(def.did));
             enc_substs(w, cx, substs);
             mywrite!(w, "]");
         }
@@ -138,7 +138,7 @@ pub fn enc_ty<'a, 'tcx>(w: &mut Encoder, cx: &ctxt<'a, 'tcx>, t: Ty<'tcx>) {
             mywrite!(w, "p[{}|{}|{}]", idx, space.to_uint(), name)
         }
         ty::TyStruct(def, substs) => {
-            mywrite!(w, "a[{}|", (cx.ds)(def));
+            mywrite!(w, "a[{}|", (cx.ds)(def.did));
             enc_substs(w, cx, substs);
             mywrite!(w, "]");
         }

src/librustc/middle/check_const.rs

@@ -546,8 +546,8 @@ impl<'a, 'tcx, 'v> Visitor<'v> for CheckCrateVisitor<'a, 'tcx> {
 fn check_expr<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>,
                         e: &ast::Expr, node_ty: Ty<'tcx>) {
     match node_ty.sty {
-        ty::TyStruct(did, _) |
-        ty::TyEnum(did, _) if v.tcx.has_dtor(did) => {
+        ty::TyStruct(def, _) |
+        ty::TyEnum(def, _) if def.has_dtor(v.tcx) => {
             v.add_qualif(ConstQualif::NEEDS_DROP);
             if v.mode != Mode::Var {
                 v.tcx.sess.span_err(e.span,

src/librustc/middle/check_match.rs

@@ -234,10 +234,10 @@ fn check_for_bindings_named_the_same_as_variants(cx: &MatchCheckCtxt, pat: &Pat)
         match p.node {
             ast::PatIdent(ast::BindByValue(ast::MutImmutable), ident, None) => {
                 let pat_ty = cx.tcx.pat_ty(p);
-                if let ty::TyEnum(def_id, _) = pat_ty.sty {
+                if let ty::TyEnum(edef, _) = pat_ty.sty {
                     let def = cx.tcx.def_map.borrow().get(&p.id).map(|d| d.full_def());
                     if let Some(DefLocal(_)) = def {
-                        if cx.tcx.enum_variants(def_id).iter().any(|variant|
+                        if cx.tcx.enum_variants(edef.did).iter().any(|variant|
                             variant.name == ident.node.name
                                 && variant.args.is_empty()
                         ) {
@@ -501,8 +501,8 @@ impl<'a, 'tcx> Folder for StaticInliner<'a, 'tcx> {
 ///
 /// left_ty: struct X { a: (bool, &'static str), b: usize}
 /// pats: [(false, "foo"), 42]  => X { a: (false, "foo"), b: 42 }
-fn construct_witness(cx: &MatchCheckCtxt, ctor: &Constructor,
-                     pats: Vec<&Pat>, left_ty: Ty) -> P<Pat> {
+fn construct_witness<'a,'tcx>(cx: &MatchCheckCtxt<'a,'tcx>, ctor: &Constructor,
+                              pats: Vec<&Pat>, left_ty: Ty<'tcx>) -> P<Pat> {
     let pats_len = pats.len();
     let mut pats = pats.into_iter().map(|p| P((*p).clone()));
     let pat = match left_ty.sty {
@@ -511,9 +511,9 @@ fn construct_witness(cx: &MatchCheckCtxt, ctor: &Constructor,
         ty::TyEnum(cid, _) | ty::TyStruct(cid, _)  => {
             let (vid, is_structure) = match ctor {
                 &Variant(vid) =>
-                    (vid, cx.tcx.enum_variant_with_id(cid, vid).arg_names.is_some()),
+                    (vid, cx.tcx.enum_variant_with_id(cid.did, vid).arg_names.is_some()),
                 _ =>
-                    (cid, !cx.tcx.is_tuple_struct(cid))
+                    (cid.did, !cid.is_tuple_struct(cx.tcx))
             };
             if is_structure {
                 let fields = cx.tcx.lookup_struct_fields(vid);
@@ -606,8 +606,8 @@ fn all_constructors(cx: &MatchCheckCtxt, left_ty: Ty,
             _ => vec!(Single)
         },
 
-        ty::TyEnum(eid, _) =>
-            cx.tcx.enum_variants(eid)
+        ty::TyEnum(edef, _) =>
+            cx.tcx.enum_variants(edef.did)
                 .iter()
                 .map(|va| Variant(va.id))
                 .collect(),
@@ -817,13 +817,13 @@ pub fn constructor_arity(cx: &MatchCheckCtxt, ctor: &Constructor, ty: Ty) -> usi
             ty::TyStr => 0,
             _ => 1
         },
-        ty::TyEnum(eid, _) => {
+        ty::TyEnum(edef, _) => {
             match *ctor {
-                Variant(id) => cx.tcx.enum_variant_with_id(eid, id).args.len(),
+                Variant(id) => cx.tcx.enum_variant_with_id(edef.did, id).args.len(),
                 _ => unreachable!()
             }
         }
-        ty::TyStruct(cid, _) => cx.tcx.lookup_struct_fields(cid).len(),
+        ty::TyStruct(cdef, _) => cx.tcx.lookup_struct_fields(cdef.did).len(),
         ty::TyArray(_, n) => n,
         _ => 0
     }

src/librustc/middle/dead.rs

@@ -101,8 +101,8 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> {
 
     fn handle_field_access(&mut self, lhs: &ast::Expr, name: ast::Name) {
         match self.tcx.expr_ty_adjusted(lhs).sty {
-            ty::TyStruct(id, _) => {
-                let fields = self.tcx.lookup_struct_fields(id);
+            ty::TyStruct(def, _) => {
+                let fields = self.tcx.lookup_struct_fields(def.did);
                 let field_id = fields.iter()
                     .find(|field| field.name == name).unwrap().id;
                 self.live_symbols.insert(field_id.node);
@@ -113,8 +113,8 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> {
 
     fn handle_tup_field_access(&mut self, lhs: &ast::Expr, idx: usize) {
         match self.tcx.expr_ty_adjusted(lhs).sty {
-            ty::TyStruct(id, _) => {
-                let fields = self.tcx.lookup_struct_fields(id);
+            ty::TyStruct(def, _) => {
+                let fields = self.tcx.lookup_struct_fields(def.did);
                 let field_id = fields[idx].id;
                 self.live_symbols.insert(field_id.node);
             },

src/librustc/middle/expr_use_visitor.rs

@@ -695,8 +695,8 @@ impl<'d,'t,'a,'tcx> ExprUseVisitor<'d,'t,'a,'tcx> {
         // Select just those fields of the `with`
         // expression that will actually be used
         let with_fields = match with_cmt.ty.sty {
-            ty::TyStruct(did, substs) => {
-                self.tcx().struct_fields(did, substs)
+            ty::TyStruct(def, substs) => {
+                self.tcx().struct_fields(def.did, substs)
             }
             _ => {
                 // the base expression should always evaluate to a
@@ -708,7 +708,6 @@ impl<'d,'t,'a,'tcx> ExprUseVisitor<'d,'t,'a,'tcx> {
                         with_expr.span,
                         "with expression doesn't evaluate to a struct");
                 }
-                assert!(self.tcx().sess.has_errors());
                 vec!()
             }
         };

src/librustc/middle/fast_reject.rs

@@ -53,15 +53,15 @@ pub fn simplify_type(tcx: &ty::ctxt,
         ty::TyInt(int_type) => Some(IntSimplifiedType(int_type)),
         ty::TyUint(uint_type) => Some(UintSimplifiedType(uint_type)),
         ty::TyFloat(float_type) => Some(FloatSimplifiedType(float_type)),
-        ty::TyEnum(def_id, _) => Some(EnumSimplifiedType(def_id)),
+        ty::TyEnum(def, _) => Some(EnumSimplifiedType(def.did)),
         ty::TyStr => Some(StrSimplifiedType),
         ty::TyArray(..) | ty::TySlice(_) => Some(VecSimplifiedType),
         ty::TyRawPtr(_) => Some(PtrSimplifiedType),
         ty::TyTrait(ref trait_info) => {
             Some(TraitSimplifiedType(trait_info.principal_def_id()))
         }
-        ty::TyStruct(def_id, _) => {
-            Some(StructSimplifiedType(def_id))
+        ty::TyStruct(def, _) => {
+            Some(StructSimplifiedType(def.did))
         }
         ty::TyRef(_, mt) => {
             // since we introduce auto-refs during method lookup, we

src/librustc/middle/implicator.rs

@@ -144,10 +144,10 @@ impl<'a, 'tcx> Implicator<'a, 'tcx> {
                 self.accumulate_from_object_ty(ty, t.bounds.region_bound, required_region_bounds)
             }
 
-            ty::TyEnum(def_id, substs) |
-            ty::TyStruct(def_id, substs) => {
-                let item_scheme = self.tcx().lookup_item_type(def_id);
-                self.accumulate_from_adt(ty, def_id, &item_scheme.generics, substs)
+            ty::TyEnum(def, substs) |
+            ty::TyStruct(def, substs) => {
+                let item_scheme = def.type_scheme(self.tcx());
+                self.accumulate_from_adt(ty, def.did, &item_scheme.generics, substs)
             }
 
             ty::TyArray(t, _) |