use VariantDef instead of struct_fields

Author: Ariel Ben-Yehuda

src/librustc/diagnostics.rs

@@ -692,64 +692,6 @@ There's no easy fix for this, generally code will need to be refactored so that
 you no longer need to derive from `Super<Self>`.
 "####,
 
-E0079: r##"
-Enum variants which contain no data can be given a custom integer
-representation. This error indicates that the value provided is not an integer
-literal and is therefore invalid.
-
-For example, in the following code,
-
-```
-enum Foo {
-    Q = "32"
-}
-```
-
-we try to set the representation to a string.
-
-There's no general fix for this; if you can work with an integer then just set
-it to one:
-
-```
-enum Foo {
-    Q = 32
-}
-```
-
-however if you actually wanted a mapping between variants and non-integer
-objects, it may be preferable to use a method with a match instead:
-
-```
-enum Foo { Q }
-impl Foo {
-    fn get_str(&self) -> &'static str {
-        match *self {
-            Foo::Q => "32",
-        }
-    }
-}
-```
-"##,
-
-E0080: r##"
-This error indicates that the compiler was unable to sensibly evaluate an
-integer expression provided as an enum discriminant. Attempting to divide by 0
-or causing integer overflow are two ways to induce this error. For example:
-
-```
-enum Enum {
-    X = (1 << 500),
-    Y = (1 / 0)
-}
-```
-
-Ensure that the expressions given can be evaluated as the desired integer type.
-See the FFI section of the Reference for more information about using a custom
-integer type:
-
-https://doc.rust-lang.org/reference.html#ffi-attributes
-"##,
-
 E0109: r##"
 You tried to give a type parameter to a type which doesn't need it. Erroneous
 code example:
@@ -1937,6 +1879,5 @@ register_diagnostics! {
     E0314, // closure outlives stack frame
     E0315, // cannot invoke closure outside of its lifetime
     E0316, // nested quantification of lifetimes
-    E0370, // discriminant overflow
     E0400  // overloaded derefs are not allowed in constants
 }

src/librustc/middle/cast.rs

@@ -58,15 +58,14 @@ pub enum CastKind {
 }
 
 impl<'tcx> CastTy<'tcx> {
-    pub fn from_ty(tcx: &ty::ctxt<'tcx>, t: Ty<'tcx>)
-                   -> Option<CastTy<'tcx>> {
+    pub fn from_ty(t: Ty<'tcx>) -> Option<CastTy<'tcx>> {
         match t.sty {
             ty::TyBool => Some(CastTy::Int(IntTy::Bool)),
             ty::TyChar => Some(CastTy::Int(IntTy::Char)),
             ty::TyInt(_) => Some(CastTy::Int(IntTy::I)),
             ty::TyUint(u) => Some(CastTy::Int(IntTy::U(u))),
             ty::TyFloat(_) => Some(CastTy::Float),
-            ty::TyEnum(..) if t.is_c_like_enum(tcx) =>
+            ty::TyEnum(d,_) if d.is_payloadfree() =>
                 Some(CastTy::Int(IntTy::CEnum)),
             ty::TyRawPtr(ref mt) => Some(CastTy::Ptr(mt)),
             ty::TyRef(_, ref mt) => Some(CastTy::RPtr(mt)),

src/librustc/middle/check_match.rs

@@ -237,9 +237,9 @@ fn check_for_bindings_named_the_same_as_variants(cx: &MatchCheckCtxt, pat: &Pat)
                 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(edef.did).iter().any(|variant|
+                        if edef.variants.iter().any(|variant|
                             variant.name == ident.node.name
-                                && variant.args.is_empty()
+                                && variant.kind() == VariantKind::Unit
                         ) {
                             span_warn!(cx.tcx.sess, p.span, E0170,
                                 "pattern binding `{}` is named the same as one \
@@ -508,16 +508,10 @@ fn construct_witness<'a,'tcx>(cx: &MatchCheckCtxt<'a,'tcx>, ctor: &Constructor,
     let pat = match left_ty.sty {
         ty::TyTuple(_) => ast::PatTup(pats.collect()),
 
-        ty::TyEnum(cid, _) | ty::TyStruct(cid, _)  => {
-            let (vid, is_structure) = match ctor {
-                &Variant(vid) =>
-                    (vid, cx.tcx.enum_variant_with_id(cid.did, vid).arg_names.is_some()),
-                _ =>
-                    (cid.did, !cid.struct_variant().is_tuple_struct())
-            };
-            if is_structure {
-                let fields = cx.tcx.lookup_struct_fields(vid);
-                let field_pats: Vec<_> = fields.into_iter()
+        ty::TyEnum(adt, _) | ty::TyStruct(adt, _)  => {
+            let v = adt.variant_of_ctor(ctor);
+            if let VariantKind::Dict = v.kind() {
+                let field_pats: Vec<_> = v.fields.iter()
                     .zip(pats)
                     .filter(|&(_, ref pat)| pat.node != ast::PatWild(ast::PatWildSingle))
                     .map(|(field, pat)| Spanned {
@@ -529,9 +523,9 @@ fn construct_witness<'a,'tcx>(cx: &MatchCheckCtxt<'a,'tcx>, ctor: &Constructor,
                         }
                     }).collect();
                 let has_more_fields = field_pats.len() < pats_len;
-                ast::PatStruct(def_to_path(cx.tcx, vid), field_pats, has_more_fields)
+                ast::PatStruct(def_to_path(cx.tcx, v.did), field_pats, has_more_fields)
             } else {
-                ast::PatEnum(def_to_path(cx.tcx, vid), Some(pats.collect()))
+                ast::PatEnum(def_to_path(cx.tcx, v.did), Some(pats.collect()))
             }
         }
 
@@ -580,6 +574,15 @@ fn construct_witness<'a,'tcx>(cx: &MatchCheckCtxt<'a,'tcx>, ctor: &Constructor,
     })
 }
 
+impl<'tcx> ADTDef<'tcx> {
+    fn variant_of_ctor(&'tcx self, ctor: &Constructor) -> &'tcx VariantDef<'tcx> {
+        match ctor {
+            &Variant(vid) => self.variant_with_id(vid),
+            _ => self.struct_variant()
+        }
+    }
+}
+
 fn missing_constructor(cx: &MatchCheckCtxt, &Matrix(ref rows): &Matrix,
                        left_ty: Ty, max_slice_length: usize) -> Option<Constructor> {
     let used_constructors: Vec<Constructor> = rows.iter()
@@ -594,7 +597,7 @@ fn missing_constructor(cx: &MatchCheckCtxt, &Matrix(ref rows): &Matrix,
 /// values of type `left_ty`. For vectors, this would normally be an infinite set
 /// but is instead bounded by the maximum fixed length of slice patterns in
 /// the column of patterns being analyzed.
-fn all_constructors(cx: &MatchCheckCtxt, left_ty: Ty,
+fn all_constructors(_cx: &MatchCheckCtxt, left_ty: Ty,
                     max_slice_length: usize) -> Vec<Constructor> {
     match left_ty.sty {
         ty::TyBool =>
@@ -603,17 +606,11 @@ fn all_constructors(cx: &MatchCheckCtxt, left_ty: Ty,
         ty::TyRef(_, ty::TypeAndMut { ty, .. }) => match ty.sty {
             ty::TySlice(_) =>
                 range_inclusive(0, max_slice_length).map(|length| Slice(length)).collect(),
-            _ => vec!(Single)
+            _ => vec![Single]
         },
 
-        ty::TyEnum(edef, _) =>
-            cx.tcx.enum_variants(edef.did)
-                .iter()
-                .map(|va| Variant(va.id))
-                .collect(),
-
-        _ =>
-            vec!(Single)
+        ty::TyEnum(def, _) => def.variants.iter().map(|v| Variant(v.did)).collect(),
+        _ => vec![Single]
     }
 }
 
@@ -804,7 +801,7 @@ fn pat_constructors(cx: &MatchCheckCtxt, p: &Pat,
 ///
 /// For instance, a tuple pattern (_, 42, Some([])) has the arity of 3.
 /// A struct pattern's arity is the number of fields it contains, etc.
-pub fn constructor_arity(cx: &MatchCheckCtxt, ctor: &Constructor, ty: Ty) -> usize {
+pub fn constructor_arity(_cx: &MatchCheckCtxt, ctor: &Constructor, ty: Ty) -> usize {
     match ty.sty {
         ty::TyTuple(ref fs) => fs.len(),
         ty::TyBox(_) => 1,
@@ -817,13 +814,9 @@ pub fn constructor_arity(cx: &MatchCheckCtxt, ctor: &Constructor, ty: Ty) -> usi
             ty::TyStr => 0,
             _ => 1
         },
-        ty::TyEnum(edef, _) => {
-            match *ctor {
-                Variant(id) => cx.tcx.enum_variant_with_id(edef.did, id).args.len(),
-                _ => unreachable!()
-            }
+        ty::TyEnum(adt, _) | ty::TyStruct(adt, _) => {
+            adt.variant_of_ctor(ctor).fields.len()
         }
-        ty::TyStruct(cdef, _) => cx.tcx.lookup_struct_fields(cdef.did).len(),
         ty::TyArray(_, n) => n,
         _ => 0
     }
@@ -902,39 +895,20 @@ pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat],
         }
 
         ast::PatStruct(_, ref pattern_fields, _) => {
-            // Is this a struct or an enum variant?
             let def = cx.tcx.def_map.borrow().get(&pat_id).unwrap().full_def();
-            let class_id = match def {
-                DefConst(..) | DefAssociatedConst(..) =>
-                    cx.tcx.sess.span_bug(pat_span, "const pattern should've \
-                                                    been rewritten"),
-                DefVariant(_, variant_id, _) => if *constructor == Variant(variant_id) {
-                    Some(variant_id)
-                } else {
-                    None
-                },
-                _ => {
-                    // Assume this is a struct.
-                    match cx.tcx.node_id_to_type(pat_id).ty_to_def_id() {
-                        None => {
-                            cx.tcx.sess.span_bug(pat_span,
-                                                 "struct pattern wasn't of a \
-                                                  type with a def ID?!")
-                        }
-                        Some(def_id) => Some(def_id),
-                    }
-                }
-            };
-            class_id.map(|variant_id| {
-                let struct_fields = cx.tcx.lookup_struct_fields(variant_id);
-                let args = struct_fields.iter().map(|sf| {
+            let adt = cx.tcx.node_id_to_type(pat_id).ty_adt_def().unwrap();
+            let variant = adt.variant_of_ctor(constructor);
+            let def_variant = adt.variant_of_def(def);
+            if variant.did == def_variant.did {
+                Some(variant.fields.iter().map(|sf| {
                     match pattern_fields.iter().find(|f| f.node.ident.name == sf.name) {
                         Some(ref f) => &*f.node.pat,
                         _ => DUMMY_WILD_PAT
                     }
-                }).collect();
-                args
-            })
+                }).collect())
+            } else {
+                None
+            }
         }
 
         ast::PatTup(ref args) =>

src/librustc/middle/dead.rs

@@ -100,51 +100,32 @@ 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(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);
-            },
-            _ => ()
+        if let ty::TyStruct(def, _) = self.tcx.expr_ty_adjusted(lhs).sty {
+            self.live_symbols.insert(def.struct_variant().field_named(name).did.node);
+        } else {
+            self.tcx.sess.span_bug(lhs.span, "named field access on non-struct")
         }
     }
 
     fn handle_tup_field_access(&mut self, lhs: &ast::Expr, idx: usize) {
-        match self.tcx.expr_ty_adjusted(lhs).sty {
-            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);
-            },
-            _ => ()
+        if let ty::TyStruct(def, _) = self.tcx.expr_ty_adjusted(lhs).sty {
+            self.live_symbols.insert(def.struct_variant().fields[idx].did.node);
         }
     }
 
     fn handle_field_pattern_match(&mut self, lhs: &ast::Pat,
                                   pats: &[codemap::Spanned<ast::FieldPat>]) {
-        let id = match self.tcx.def_map.borrow().get(&lhs.id).unwrap().full_def() {
-            def::DefVariant(_, id, _) => id,
-            _ => {
-                match self.tcx.node_id_to_type(lhs.id).ty_to_def_id() {
-                    None => {
-                        self.tcx.sess.span_bug(lhs.span,
-                                               "struct pattern wasn't of a \
-                                                type with a def ID?!")
-                    }
-                    Some(def_id) => def_id,
-                }
-            }
+        let def = self.tcx.def_map.borrow().get(&lhs.id).unwrap().full_def();
+        let pat_ty = self.tcx.node_id_to_type(lhs.id);
+        let variant = match pat_ty.sty {
+            ty::TyStruct(adt, _) | ty::TyEnum(adt, _) => adt.variant_of_def(def),
+            _ => self.tcx.sess.span_bug(lhs.span, "non-ADT in struct pattern")
         };
-        let fields = self.tcx.lookup_struct_fields(id);
         for pat in pats {
             if let ast::PatWild(ast::PatWildSingle) = pat.node.pat.node {
                 continue;
             }
-            let field_id = fields.iter()
-                .find(|field| field.name == pat.node.ident.name).unwrap().id;
-            self.live_symbols.insert(field_id.node);
+            self.live_symbols.insert(variant.field_named(pat.node.ident.name).did.node);
         }
     }
 

src/librustc/middle/expr_use_visitor.rs

@@ -694,40 +694,36 @@ 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(def, substs) => {
-                self.tcx().struct_fields(def.did, substs)
-            }
-            _ => {
-                // the base expression should always evaluate to a
-                // struct; however, when EUV is run during typeck, it
-                // may not. This will generate an error earlier in typeck,
-                // so we can just ignore it.
-                if !self.tcx().sess.has_errors() {
-                    self.tcx().sess.span_bug(
-                        with_expr.span,
-                        "with expression doesn't evaluate to a struct");
+        if let ty::TyStruct(def, substs) = with_cmt.ty.sty {
+            // Consume those fields of the with expression that are needed.
+            for with_field in &def.struct_variant().fields {
+                if !contains_field_named(with_field, fields) {
+                    let cmt_field = self.mc.cat_field(
+                        &*with_expr,
+                        with_cmt.clone(),
+                        with_field.name,
+                        with_field.ty(self.tcx(), substs)
+                    );
+                    self.delegate_consume(with_expr.id, with_expr.span, cmt_field);
                 }
-                vec!()
             }
-        };
-
-        // Consume those fields of the with expression that are needed.
-        for with_field in &with_fields {
-            if !contains_field_named(with_field, fields) {
-                let cmt_field = self.mc.cat_field(&*with_expr,
-                                                  with_cmt.clone(),
-                                                  with_field.name,
-                                                  with_field.mt.ty);
-                self.delegate_consume(with_expr.id, with_expr.span, cmt_field);
+        } else {
+            // the base expression should always evaluate to a
+            // struct; however, when EUV is run during typeck, it
+            // may not. This will generate an error earlier in typeck,
+            // so we can just ignore it.
+            if !self.tcx().sess.has_errors() {
+                self.tcx().sess.span_bug(
+                    with_expr.span,
+                    "with expression doesn't evaluate to a struct");
             }
-        }
+        };
 
         // walk the with expression so that complex expressions
         // are properly handled.
         self.walk_expr(with_expr);
 
-        fn contains_field_named(field: &ty::Field,
+        fn contains_field_named(field: &ty::FieldDef,
                                 fields: &Vec<ast::Field>)
                                 -> bool
         {
@@ -1105,7 +1101,7 @@ impl<'d,'t,'a,'tcx> ExprUseVisitor<'d,'t,'a,'tcx> {
 
                         Some(def::DefVariant(enum_did, variant_did, _is_struct)) => {
                             let downcast_cmt =
-                                if tcx.enum_is_univariant(enum_did) {
+                                if tcx.lookup_adt_def(enum_did).is_univariant() {
                                     cmt_pat
                                 } else {
                                     let cmt_pat_ty = cmt_pat.ty;

src/librustc/middle/mem_categorization.rs

@@ -1216,7 +1216,7 @@ impl<'t, 'a,'tcx> MemCategorizationContext<'t, 'a, 'tcx> {
         let cmt = match opt_def {
             Some(def::DefVariant(enum_did, variant_did, _))
                 // univariant enums do not need downcasts
-                if !self.tcx().enum_is_univariant(enum_did) => {
+                if !self.tcx().lookup_adt_def(enum_did).is_univariant() => {
                     self.cat_downcast(pat, cmt.clone(), cmt.ty, variant_did)
                 }
             _ => cmt