AdtDef now contains discr_ty same as layouted

Author: nagisa

src/Cargo.lock

@@ -382,6 +382,23 @@ impl Integer {
         }
     }
 
+    pub fn to_attr(&self, signed: bool) -> attr::IntType {
+        match (*self, signed) {
+            (I1, false) => attr::IntType::UnsignedInt(UintTy::U8),
+            (I8, false) => attr::IntType::UnsignedInt(UintTy::U8),
+            (I16, false) => attr::IntType::UnsignedInt(UintTy::U16),
+            (I32, false) => attr::IntType::UnsignedInt(UintTy::U32),
+            (I64, false) => attr::IntType::UnsignedInt(UintTy::U64),
+            (I128, false) => attr::IntType::UnsignedInt(UintTy::U128),
+            (I1, true) => attr::IntType::SignedInt(IntTy::I8),
+            (I8, true) => attr::IntType::SignedInt(IntTy::I8),
+            (I16, true) => attr::IntType::SignedInt(IntTy::I16),
+            (I32, true) => attr::IntType::SignedInt(IntTy::I32),
+            (I64, true) => attr::IntType::SignedInt(IntTy::I64),
+            (I128, true) => attr::IntType::SignedInt(IntTy::I128),
+        }
+    }
+
     /// Find the smallest Integer type which can represent the signed value.
     pub fn fit_signed(x: i64) -> Integer {
         match x {
@@ -436,13 +453,13 @@ 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, hints: &[attr::ReprAttr], min: i64, max: i64)
-                      -> (Integer, bool) {
+    pub fn repr_discr(tcx: TyCtxt, hints: &[attr::ReprAttr], 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
         // are any negative values, the only valid unsigned representation is u64
         // which can fit all i64 values, so the result remains unaffected.
-        let unsigned_fit = Integer::fit_unsigned(cmp::max(min as u64, max as u64));
+        let unsigned_fit = Integer::fit_unsigned(cmp::max(min as u128, max as u128));
         let signed_fit = cmp::max(Integer::fit_signed(min), Integer::fit_signed(max));
 
         let mut min_from_extern = None;
@@ -455,7 +472,7 @@ impl Integer {
                     let fit = if ity.is_signed() { signed_fit } else { unsigned_fit };
                     if discr < fit {
                         bug!("Integer::repr_discr: `#[repr]` hint too small for \
-                              discriminant range of enum `{}", ty)
+                              discriminant range of enum")
                     }
                     return (discr, ity.is_signed());
                 }
@@ -471,16 +488,15 @@ impl Integer {
                 }
                 attr::ReprAny => {},
                 attr::ReprPacked => {
-                    bug!("Integer::repr_discr: found #[repr(packed)] on enum `{}", ty);
+                    bug!("Integer::repr_discr: found #[repr(packed)] on enum");
                 }
                 attr::ReprSimd => {
-                    bug!("Integer::repr_discr: found #[repr(simd)] on enum `{}", ty);
+                    bug!("Integer::repr_discr: found #[repr(simd)] on enum");
                 }
             }
         }
 
         let at_least = min_from_extern.unwrap_or(min_default);
-
         // If there are no negative values, we can use the unsigned fit.
         if min >= 0 {
             (cmp::max(unsigned_fit, at_least), false)
@@ -1220,9 +1236,8 @@ impl<'a, 'gcx, 'tcx> Layout {
 
                     // FIXME: should handle i128? signed-value based impl is weird and hard to
                     // grok.
-                    let (discr, signed) = Integer::repr_discr(tcx, ty, &hints[..],
-                                                              min,
-                                                              max);
+                    let discr = Integer::from_attr(&tcx.data_layout, def.discr_ty);
+                    let signed = def.discr_ty.is_signed();
                     return success(CEnum {
                         discr: discr,
                         signed: signed,
@@ -1337,10 +1352,7 @@ impl<'a, 'gcx, 'tcx> Layout {
                 }
 
                 // The general case.
-                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 min_ity = Integer::from_attr(&tcx.data_layout, def.discr_ty);
                 let mut align = dl.aggregate_align;
                 let mut size = Size::from_bytes(0);
 

src/librustc/ty/layout.rs

@@ -22,3 +22,4 @@ rustc_data_structures = { path = "../librustc_data_structures" }
 rustc_platform_intrinsics = { path = "../librustc_platform_intrinsics" }
 syntax_pos = { path = "../libsyntax_pos" }
 rustc_errors = { path = "../librustc_errors" }
+rustc_i128 = { path = "../librustc_i128" }

src/librustc_typeck/Cargo.toml

@@ -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};
-use rustc::ty::{self, AdtKind, ToPolyTraitRef, Ty, TyCtxt};
+use rustc::ty::{self, AdtKind, ToPolyTraitRef, Ty, TyCtxt, layout};
 use rustc::ty::util::IntTypeExt;
 use rustc::dep_graph::DepNode;
 use util::common::{ErrorReported, MemoizationMap};
@@ -86,6 +86,8 @@ 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
 
@@ -1090,9 +1092,11 @@ fn convert_enum_def<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
     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 variants = def.variants.iter().map(|v| {
         let wrapped_disr = prev_disr.map_or(initial, |d| d.wrapping_add(1));
         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) {
             Some(disr)
@@ -1106,12 +1110,14 @@ 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)
     }).collect();
 
-    let adt = tcx.alloc_adt_def(did, AdtKind::Enum, Some(repr_type), variants);
+    let (repr_int, signed) = layout::Integer::repr_discr(tcx, &repr_hints[..], min, max);
+    let adt = tcx.alloc_adt_def(did, AdtKind::Enum, Some(repr_int.to_attr(signed)), variants);
     tcx.adt_defs.borrow_mut().insert(did, adt);
     adt
 }

src/librustc_typeck/collect.rs

@@ -98,6 +98,8 @@ extern crate rustc_const_eval;
 extern crate rustc_data_structures;
 extern crate rustc_errors as errors;
 
+extern crate rustc_i128;
+
 pub use rustc::dep_graph;
 pub use rustc::hir;
 pub use rustc::lint;