Revert use of layout code in typeck::collect

Author: nagisa

src/librustc/ty/layout.rs

@@ -453,7 +453,7 @@ impl Integer {
     /// signed discriminant range and #[repr] attribute.
     /// N.B.: u64 values above i64::MAX will be treated as signed, but
     /// that shouldn't affect anything, other than maybe debuginfo.
-    fn repr_discr(tcx: TyCtxt, ty: Ty, repr: &ReprOptions, min: i128, max: i128)
+    pub fn repr_discr(tcx: TyCtxt, ty: Ty, repr: &ReprOptions, min: i128, max: i128)
                       -> (Integer, bool) {
         // Theoretically, negative values could be larger in unsigned representation
         // than the unsigned representation of the signed minimum. However, if there
@@ -1212,8 +1212,7 @@ impl<'a, 'gcx, 'tcx> Layout {
 
                     // FIXME: should handle i128? signed-value based impl is weird and hard to
                     // grok.
-                    let discr = Integer::from_attr(&tcx.data_layout, def.discr_ty);
-                    let signed = def.discr_ty.is_signed();
+                    let (discr, signed) = Integer::repr_discr(tcx, ty, hints, min, max);
                     return success(CEnum {
                         discr: discr,
                         signed: signed,
@@ -1328,7 +1327,9 @@ impl<'a, 'gcx, 'tcx> Layout {
                 }
 
                 // The general case.
-                let min_ity = Integer::from_attr(&tcx.data_layout, def.discr_ty);
+                let discr_max = (variants.len() - 1) as i64;
+                assert!(discr_max >= 0);
+                let (min_ity, _) = Integer::repr_discr(tcx, ty, &hints[..], 0, discr_max);
                 let mut align = dl.aggregate_align;
                 let mut size = Size::from_bytes(0);
 

src/librustc/ty/mod.rs

@@ -1326,7 +1326,12 @@ pub struct FieldDef {
 /// table.
 pub struct AdtDef {
     pub did: DefId,
-    pub discr_ty: attr::IntType, // Type of the discriminant
+    /// Type of the discriminant
+    ///
+    /// Note, that this is the type specified in `repr()` or a default type of some sort, and might
+    /// not match the actual type that layout algorithm decides to use when translating this type
+    /// into LLVM. That being said, layout algorithm may not use a type larger than specified here.
+    pub discr_ty: attr::IntType,
     pub variants: Vec<VariantDef>,
     destructor: Cell<Option<DefId>>,
     flags: Cell<AdtFlags>,

src/librustc/ty/util.rs

@@ -23,7 +23,6 @@ use ty::TypeVariants::*;
 use util::nodemap::FxHashMap;
 use middle::lang_items;
 
-use rustc_const_math::ConstInt;
 use rustc_data_structures::stable_hasher::{StableHasher, StableHasherResult};
 
 use std::cell::RefCell;
@@ -34,14 +33,10 @@ use syntax::ast::{self, Name};
 use syntax::attr::{self, SignedInt, UnsignedInt};
 use syntax_pos::Span;
 
-use rustc_i128::i128;
-
 use hir;
 
 pub trait IntTypeExt {
     fn to_ty<'a, 'gcx: 'a+'tcx, 'tcx: 'a>(self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Ty<'tcx>;
-    fn disr_incr<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, val: Option<Disr>)
-                           -> Option<Disr>;
     fn initial_discriminant<'a, 'tcx>(&self, _: TyCtxt<'a, 'tcx, 'tcx>) -> Disr;
 }
 
@@ -56,19 +51,6 @@ impl IntTypeExt for attr::IntType {
     fn initial_discriminant<'a, 'tcx>(&self, _: TyCtxt<'a, 'tcx, 'tcx>) -> Disr {
         0
     }
-
-    /// None = overflow
-    fn disr_incr<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, val: Option<Disr>)
-    -> Option<Disr> {
-        if let Some(val) = val {
-            match *self {
-                SignedInt(it) => ConstInt::new_signed(val as i128, it, tcx.sess.target.int_type),
-                UnsignedInt(it) => ConstInt::new_unsigned(val, it, tcx.sess.target.uint_type),
-            }.and_then(|l| (l + ConstInt::Infer(1)).ok()).map(|v| v.to_u128_unchecked())
-        } else {
-            Some(self.initial_discriminant(tcx))
-        }
-    }
 }
 
 

src/librustc_trans/mir/rvalue.rs

@@ -438,12 +438,8 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
                 let enum_ty = discr_lvalue.ty.to_ty(bcx.tcx());
                 let discr_ty = rvalue.ty(&*self.mir, bcx.tcx()).unwrap();
                 let discr_type = type_of::immediate_type_of(bcx.ccx, discr_ty);
-                let discr = adt::trans_get_discr(&bcx, enum_ty, discr_lvalue.llval, None, true);
-                let discr = if common::val_ty(discr) == Type::i1(bcx.ccx) {
-                    bcx.zext(discr, discr_type)
-                } else {
-                    bcx.trunc(discr, discr_type)
-                };
+                let discr = adt::trans_get_discr(&bcx, enum_ty, discr_lvalue.llval,
+                                                 Some(discr_type), true);
                 (bcx, OperandRef {
                     val: OperandValue::Immediate(discr),
                     ty: discr_ty

src/librustc_typeck/collect.rs

@@ -66,7 +66,7 @@ use rustc_const_eval::EvalHint::UncheckedExprHint;
 use rustc_const_eval::{ConstContext, report_const_eval_err};
 use rustc::ty::subst::Substs;
 use rustc::ty::{ToPredicate, ImplContainer, AssociatedItemContainer, TraitContainer, ReprOptions};
-use rustc::ty::{self, AdtKind, ToPolyTraitRef, Ty, TyCtxt, layout};
+use rustc::ty::{self, AdtKind, ToPolyTraitRef, Ty, TyCtxt};
 use rustc::ty::util::IntTypeExt;
 use rustc::dep_graph::DepNode;
 use util::common::{ErrorReported, MemoizationMap};
@@ -86,8 +86,6 @@ use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
 use rustc::hir::def::{Def, CtorKind};
 use rustc::hir::def_id::DefId;
 
-use rustc_i128::i128;
-
 ///////////////////////////////////////////////////////////////////////////
 // Main entry point
 
@@ -1032,7 +1030,7 @@ fn convert_union_def<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
 }
 
 fn evaluate_disr_expr(ccx: &CrateCtxt, repr_ty: attr::IntType, body: hir::BodyId)
-                      -> Option<ty::Disr> {
+                      -> Option<ConstInt> {
     let e = &ccx.tcx.hir.body(body).value;
     debug!("disr expr, checking {}", ccx.tcx.hir.node_to_pretty_string(e.id));
 
@@ -1062,7 +1060,7 @@ fn evaluate_disr_expr(ccx: &CrateCtxt, repr_ty: attr::IntType, body: hir::BodyId
                 (attr::UnsignedInt(ast::UintTy::U64), ConstInt::U64(_)) |
                 (attr::UnsignedInt(ast::UintTy::U128), ConstInt::U128(_)) |
                 (attr::UnsignedInt(ast::UintTy::Us), ConstInt::Usize(_)) =>
-                    Some(i.to_u128_unchecked()),
+                    Some(i),
                 (_, i) => {
                     print_err(ConstVal::Integral(i));
                     None
@@ -1093,15 +1091,17 @@ fn convert_enum_def<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
     let did = tcx.hir.local_def_id(it.id);
     let repr_hints = tcx.lookup_repr_hints(did);
     let repr_type = tcx.enum_repr_type(repr_hints.get(0));
-    let initial = repr_type.initial_discriminant(tcx);
-    let mut prev_disr = None::<ty::Disr>;
-    let (mut min, mut max) = (i128::max_value(), i128::min_value());
+    let initial = ConstInt::new_inttype(repr_type.initial_discriminant(tcx), repr_type,
+                                        tcx.sess.target.uint_type, tcx.sess.target.int_type)
+        .unwrap();
+    let mut prev_disr = None::<ConstInt>;
     let variants = def.variants.iter().map(|v| {
-        let wrapped_disr = prev_disr.map_or(initial, |d| d.wrapping_add(1));
+        let wrapped_disr = prev_disr.map_or(initial, |d| d.wrap_incr());
         let disr = if let Some(e) = v.node.disr_expr {
             // FIXME: i128 discriminants
             evaluate_disr_expr(ccx, repr_type, e)
-        } else if let Some(disr) = repr_type.disr_incr(tcx, prev_disr) {
+        } else if let Some(disr) = prev_disr.map_or(Some(initial),
+                                                    |v| (v + ConstInt::Infer(1)).ok()) {
             Some(disr)
         } else {
             struct_span_err!(tcx.sess, v.span, E0370,
@@ -1113,13 +1113,10 @@ fn convert_enum_def<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
             None
         }.unwrap_or(wrapped_disr);
         prev_disr = Some(disr);
-        if (disr as i128) < min { min = disr as i128; }
-        if (disr as i128) > max { max = disr as i128; }
         let did = tcx.hir.local_def_id(v.node.data.id());
-        convert_struct_variant(ccx, did, v.node.name, disr, &v.node.data)
+        convert_struct_variant(ccx, did, v.node.name, disr.to_u128_unchecked(), &v.node.data)
     }).collect();
-
-    let adt = tcx.alloc_adt_def(did, AdtKind::Enum, Some(repr_int.to_attr(signed)), variants,
+    let adt = tcx.alloc_adt_def(did, AdtKind::Enum, Some(repr_type), variants,
                                 ReprOptions::new(&ccx.tcx, did));
     tcx.adt_defs.borrow_mut().insert(did, adt);
     adt