it compiles!

Author: Ariel Ben-Yehuda

src/librustc_lint/builtin.rs

@@ -45,7 +45,6 @@ use std::collections::{HashSet, BitSet};
 use std::collections::hash_map::Entry::{Occupied, Vacant};
 use std::{cmp, slice};
 use std::{i8, i16, i32, i64, u8, u16, u32, u64, f32, f64};
-use std::rc::Rc;
 
 use syntax::{abi, ast};
 use syntax::ast_util::{self, is_shift_binop, local_def};
@@ -413,18 +412,21 @@ enum FfiResult {
 /// to function pointers and references, but could be
 /// expanded to cover NonZero raw pointers and newtypes.
 /// FIXME: This duplicates code in trans.
-fn is_repr_nullable_ptr<'tcx>(variants: &Vec<Rc<ty::VariantInfo<'tcx>>>) -> bool {
-    if variants.len() == 2 {
+fn is_repr_nullable_ptr<'tcx>(tcx: &ty::ctxt<'tcx>,
+                              def: &ty::ADTDef<'tcx>,
+                              substs: &Substs<'tcx>)
+                              -> bool {
+    if def.variants.len() == 2 {
         let mut data_idx = 0;
 
-        if variants[0].args.is_empty() {
+        if def.variants[0].fields.is_empty() {
             data_idx = 1;
-        } else if !variants[1].args.is_empty() {
+        } else if !def.variants[1].fields.is_empty() {
             return false;
         }
 
-        if variants[data_idx].args.len() == 1 {
-            match variants[data_idx].args[0].sty {
+        if def.variants[data_idx].fields.len() == 1 {
+            match def.variants[data_idx].fields[0].ty(tcx, substs).sty {
                 ty::TyBareFn(None, _) => { return true; }
                 ty::TyRef(..) => { return true; }
                 _ => { }
@@ -474,16 +476,14 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
 
                 // We can't completely trust repr(C) markings; make sure the
                 // fields are actually safe.
-                let fields = cx.struct_fields(def.did, substs);
-
-                if fields.is_empty() {
+                if def.struct_variant().fields.is_empty() {
                     return FfiUnsafe(
                         "found zero-size struct in foreign module, consider \
                          adding a member to this struct");
                 }
 
-                for field in fields {
-                    let field_ty = infer::normalize_associated_type(cx, &field.mt.ty);
+                for field in &def.struct_variant().fields {
+                    let field_ty = infer::normalize_associated_type(cx, &field.ty(cx, substs));
                     let r = self.check_type_for_ffi(cache, field_ty);
                     match r {
                         FfiSafe => {}
@@ -494,8 +494,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
                 FfiSafe
             }
             ty::TyEnum(def, substs) => {
-                let variants = cx.substd_enum_variants(def.did, substs);
-                if variants.is_empty() {
+                if def.variants.is_empty() {
                     // Empty enums are okay... although sort of useless.
                     return FfiSafe
                 }
@@ -506,7 +505,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
                 match &**repr_hints {
                     [] => {
                         // Special-case types like `Option<extern fn()>`.
-                        if !is_repr_nullable_ptr(&variants) {
+                        if !is_repr_nullable_ptr(cx, def, substs) {
                             return FfiUnsafe(
                                 "found enum without foreign-function-safe \
                                  representation annotation in foreign module, \
@@ -537,9 +536,9 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
                 }
 
                 // Check the contained variants.
-                for variant in variants {
-                    for arg in &variant.args {
-                        let arg = infer::normalize_associated_type(cx, arg);
+                for variant in &def.variants {
+                    for field in &variant.fields {
+                        let arg = infer::normalize_associated_type(cx, &field.ty(cx, substs));
                         let r = self.check_type_for_ffi(cache, arg);
                         match r {
                             FfiSafe => {}

src/librustc_privacy/lib.rs

@@ -34,7 +34,6 @@ use self::FieldName::*;
 use std::mem::replace;
 
 use rustc::ast_map;
-use rustc::metadata::csearch;
 use rustc::middle::def;
 use rustc::middle::privacy::ImportUse::*;
 use rustc::middle::privacy::LastPrivate::*;
@@ -688,29 +687,26 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> {
     // Checks that a field is in scope.
     fn check_field(&mut self,
                    span: Span,
-                   id: ast::DefId,
+                   def: &'tcx ty::ADTDef<'tcx>,
+                   v: &'tcx ty::VariantDef<'tcx>,
                    name: FieldName) {
-        // TODO: refactor to variant API
-        let fields = self.tcx.lookup_struct_fields(id);
         let field = match name {
             NamedField(f_name) => {
-                debug!("privacy - check named field {} in struct {:?}", f_name, id);
-                fields.iter().find(|f| f.name == f_name).unwrap()
+                debug!("privacy - check named field {} in struct {:?}", f_name, def);
+                v.field_named(f_name)
             }
-            UnnamedField(idx) => &fields[idx]
+            UnnamedField(idx) => &v.fields[idx]
         };
         if field.vis == ast::Public ||
-            (is_local(field.id) && self.private_accessible(field.id.node)) {
+            (is_local(field.did) && self.private_accessible(field.did.node)) {
             return
         }
 
-        let struct_type = self.tcx.lookup_item_type(id).ty;
-        let struct_desc = match struct_type.sty {
-            ty::TyStruct(_, _) =>
-                format!("struct `{}`", self.tcx.item_path_str(id)),
+        let struct_desc = match def.adt_kind() {
+            ty::ADTKind::Struct =>
+                format!("struct `{}`", self.tcx.item_path_str(def.did)),
             // struct variant fields have inherited visibility
-            ty::TyEnum(..) => return,
-            _ => self.tcx.sess.span_bug(span, "can't find struct for field")
+            ty::ADTKind::Enum => return
         };
         let msg = match name {
             NamedField(name) => format!("field `{}` of {} is private",
@@ -885,12 +881,18 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> {
         match expr.node {
             ast::ExprField(ref base, ident) => {
                 if let ty::TyStruct(def, _) = self.tcx.expr_ty_adjusted(&**base).sty {
-                    self.check_field(expr.span, def.did, NamedField(ident.node.name));
+                    self.check_field(expr.span,
+                                     def,
+                                     def.struct_variant(),
+                                     NamedField(ident.node.name));
                 }
             }
             ast::ExprTupField(ref base, idx) => {
                 if let ty::TyStruct(def, _) = self.tcx.expr_ty_adjusted(&**base).sty {
-                    self.check_field(expr.span, def.did, UnnamedField(idx.node));
+                    self.check_field(expr.span,
+                                     def,
+                                     def.struct_variant(),
+                                     UnnamedField(idx.node));
                 }
             }
             ast::ExprMethodCall(ident, _, _) => {
@@ -899,67 +901,31 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> {
                 debug!("(privacy checking) checking impl method");
                 self.check_method(expr.span, method.def_id, ident.node.name);
             }
-            ast::ExprStruct(_, ref fields, _) => {
-                match self.tcx.expr_ty(expr).sty {
-                    ty::TyStruct(ctor_def, _) => {
-                        // RFC 736: ensure all unmentioned fields are visible.
-                        // Rather than computing the set of unmentioned fields
-                        // (i.e. `all_fields - fields`), just check them all.
-                        let all_fields = self.tcx.lookup_struct_fields(ctor_def.did);
-                        for field in all_fields {
-                            self.check_field(expr.span, ctor_def.did,
-                                             NamedField(field.name));
-                        }
-                    }
-                    ty::TyEnum(_, _) => {
-                        match self.tcx.def_map.borrow().get(&expr.id).unwrap().full_def() {
-                            def::DefVariant(_, variant_id, _) => {
-                                for field in fields {
-                                    self.check_field(expr.span, variant_id,
-                                                     NamedField(field.ident.node.name));
-                                }
-                            }
-                            _ => self.tcx.sess.span_bug(expr.span,
-                                                        "resolve didn't \
-                                                         map enum struct \
-                                                         constructor to a \
-                                                         variant def"),
-                        }
-                    }
-                    _ => self.tcx.sess.span_bug(expr.span, "struct expr \
-                                                            didn't have \
-                                                            struct type?!"),
+            ast::ExprStruct(..) => {
+                let adt = self.tcx.expr_ty(expr).ty_adt_def().unwrap();
+                let variant = adt.variant_of_def(self.tcx.resolve_expr(expr));
+                // RFC 736: ensure all unmentioned fields are visible.
+                // Rather than computing the set of unmentioned fields
+                // (i.e. `all_fields - fields`), just check them all.
+                for field in &variant.fields {
+                    self.check_field(expr.span, adt, variant, NamedField(field.name));
                 }
             }
             ast::ExprPath(..) => {
-                let guard = |did: ast::DefId| {
-                    let fields = self.tcx.lookup_struct_fields(did);
-                    let any_priv = fields.iter().any(|f| {
-                        f.vis != ast::Public && (
-                            !is_local(f.id) ||
-                            !self.private_accessible(f.id.node))
-                    });
-                    if any_priv {
-                        self.tcx.sess.span_err(expr.span,
-                            "cannot invoke tuple struct constructor \
-                             with private fields");
-                    }
-                };
-                match self.tcx.def_map.borrow().get(&expr.id).map(|d| d.full_def()) {
-                    Some(def::DefStruct(did)) => {
-                        guard(if is_local(did) {
-                            local_def(self.tcx.map.get_parent(did.node))
-                        } else {
-                            // "tuple structs" with zero fields (such as
-                            // `pub struct Foo;`) don't have a ctor_id, hence
-                            // the unwrap_or to the same struct id.
-                            let maybe_did =
-                                csearch::get_tuple_struct_definition_if_ctor(
-                                    &self.tcx.sess.cstore, did);
-                            maybe_did.unwrap_or(did)
-                        })
+                if let def::DefStruct(_) = self.tcx.resolve_expr(expr) {
+                    if let ty::TyStruct(def, _) = self.tcx.expr_ty(expr).sty {
+                        let fields = &def.struct_variant().fields;
+                        let any_priv = fields.iter().any(|f| {
+                            f.vis != ast::Public && (
+                                !is_local(f.did) ||
+                                    !self.private_accessible(f.did.node))
+                        });
+                        if any_priv {
+                            self.tcx.sess.span_err(expr.span,
+                                                   "cannot invoke tuple struct constructor \
+                                                    with private fields");
+                        }
                     }
-                    _ => {}
                 }
             }
             _ => {}
@@ -977,31 +943,12 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> {
 
         match pattern.node {
             ast::PatStruct(_, ref fields, _) => {
-                match self.tcx.pat_ty(pattern).sty {
-                    ty::TyStruct(def, _) => {
-                        for field in fields {
-                            self.check_field(pattern.span, def.did,
-                                             NamedField(field.node.ident.name));
-                        }
-                    }
-                    ty::TyEnum(_, _) => {
-                        match self.tcx.def_map.borrow().get(&pattern.id).map(|d| d.full_def()) {
-                            Some(def::DefVariant(_, variant_id, _)) => {
-                                for field in fields {
-                                    self.check_field(pattern.span, variant_id,
-                                                     NamedField(field.node.ident.name));
-                                }
-                            }
-                            _ => self.tcx.sess.span_bug(pattern.span,
-                                                        "resolve didn't \
-                                                         map enum struct \
-                                                         pattern to a \
-                                                         variant def"),
-                        }
-                    }
-                    _ => self.tcx.sess.span_bug(pattern.span,
-                                                "struct pattern didn't have \
-                                                 struct type?!"),
+                let adt = self.tcx.pat_ty(pattern).ty_adt_def().unwrap();
+                let def = self.tcx.def_map.borrow().get(&pattern.id).unwrap().full_def();
+                let variant = adt.variant_of_def(def);
+                for field in fields {
+                    self.check_field(pattern.span, adt, variant,
+                                     NamedField(field.node.ident.name));
                 }
             }
 
@@ -1014,7 +961,10 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> {
                             if let ast::PatWild(..) = field.node {
                                 continue
                             }
-                            self.check_field(field.span, def.did, UnnamedField(i));
+                            self.check_field(field.span,
+                                             def,
+                                             def.struct_variant(),
+                                             UnnamedField(i));
                         }
                     }
                     ty::TyEnum(..) => {

src/librustc_trans/trans/_match.rs

@@ -1191,8 +1191,7 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
                 // since we can only ever match that field behind
                 // a reference we construct a fat ptr here.
                 let unsized_ty = def.struct_variant().fields.last().map(|field| {
-                    let fty = field.ty(bcx.tcx(), substs);
-                    monomorphize::normalize_associated_type(bcx.tcx(), &fty)
+                    monomorphize::field_ty(bcx.tcx(), substs, field)
                 }).unwrap();
                 let llty = type_of::type_of(bcx.ccx(), unsized_ty);
                 let scratch = alloca_no_lifetime(bcx, llty, "__struct_field_fat_ptr");

src/librustc_trans/trans/adt.rs

@@ -246,10 +246,8 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
             Univariant(mk_struct(cx, &elems[..], false, t), 0)
         }
         ty::TyStruct(def, substs) => {
-            let fields = cx.tcx().lookup_struct_fields(def.did);
-            let mut ftys = fields.iter().map(|field| {
-                let fty = cx.tcx().lookup_field_type(def.did, field.id, substs);
-                monomorphize::normalize_associated_type(cx.tcx(), &fty)
+            let mut ftys = def.struct_variant().fields.iter().map(|field| {
+                monomorphize::field_ty(cx.tcx(), substs, field)
             }).collect::<Vec<_>>();
             let packed = cx.tcx().lookup_packed(def.did);
             let dtor = cx.tcx().ty_dtor(def.did).has_drop_flag();
@@ -263,7 +261,7 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
             Univariant(mk_struct(cx, &substs.upvar_tys, false, t), 0)
         }
         ty::TyEnum(def, substs) => {
-            let cases = get_cases(cx.tcx(), def.did, substs);
+            let cases = get_cases(cx.tcx(), def, substs);
             let hint = *cx.tcx().lookup_repr_hints(def.did).get(0)
                 .unwrap_or(&attr::ReprAny);
 
@@ -444,10 +442,10 @@ fn find_discr_field_candidate<'tcx>(tcx: &ty::ctxt<'tcx>,
 
         // Is this the NonZero lang item wrapping a pointer or integer type?
         ty::TyStruct(def, substs) if Some(def.did) == tcx.lang_items.non_zero() => {
-            let nonzero_fields = tcx.lookup_struct_fields(def.did);
+            let nonzero_fields = &def.struct_variant().fields;
             assert_eq!(nonzero_fields.len(), 1);
-            let nonzero_field = tcx.lookup_field_type(def.did, nonzero_fields[0].id, substs);
-            match nonzero_field.sty {
+            let field_ty = monomorphize::field_ty(tcx, substs, &nonzero_fields[0]);
+            match field_ty.sty {
                 ty::TyRawPtr(ty::TypeAndMut { ty, .. }) if !type_is_sized(tcx, ty) => {
                     path.push_all(&[0, FAT_PTR_ADDR]);
                     Some(path)
@@ -463,9 +461,9 @@ fn find_discr_field_candidate<'tcx>(tcx: &ty::ctxt<'tcx>,
         // Perhaps one of the fields of this struct is non-zero
         // let's recurse and find out
         ty::TyStruct(def, substs) => {
-            let fields = tcx.lookup_struct_fields(def.did);
-            for (j, field) in fields.iter().enumerate() {
-                let field_ty = tcx.lookup_field_type(def.did, field.id, substs);
+            for (j, field) in def.struct_variant().fields.iter().enumerate() {
+                // TODO(#27532)
+                let field_ty = field.ty(tcx, substs);
                 if let Some(mut fpath) = find_discr_field_candidate(tcx, field_ty, path.clone()) {
                     fpath.push(j);
                     return Some(fpath);
@@ -530,14 +528,14 @@ impl<'tcx> Case<'tcx> {
 }
 
 fn get_cases<'tcx>(tcx: &ty::ctxt<'tcx>,
-                   def_id: ast::DefId,
+                   adt: &ty::ADTDef<'tcx>,
                    substs: &subst::Substs<'tcx>)
                    -> Vec<Case<'tcx>> {
-    tcx.enum_variants(def_id).iter().map(|vi| {
-        let arg_tys = vi.args.iter().map(|&raw_ty| {
-            monomorphize::apply_param_substs(tcx, substs, &raw_ty)
+    adt.variants.iter().map(|vi| {
+        let field_tys = vi.fields.iter().map(|field| {
+            monomorphize::field_ty(tcx, substs, field)
         }).collect();
-        Case { discr: vi.disr_val, tys: arg_tys }
+        Case { discr: vi.disr_val, tys: field_tys }
     }).collect()
 }