Fix the IntTypeExt::to_ty() lifetime bounds

Author: nagisa

src/librustc/mir/tcx.rs

@@ -17,8 +17,8 @@ use mir::*;
 use ty::subst::{Subst, Substs};
 use ty::{self, AdtDef, Ty, TyCtxt};
 use ty::fold::{TypeFoldable, TypeFolder, TypeVisitor};
-use syntax::attr;
 use hir;
+use ty::util::IntTypeExt;
 
 #[derive(Copy, Clone, Debug)]
 pub enum LvalueTy<'tcx> {
@@ -172,13 +172,7 @@ impl<'tcx> Rvalue<'tcx> {
             }
             Rvalue::Discriminant(ref lval) => {
                 if let ty::TyAdt(adt_def, _) = lval.ty(mir, tcx).to_ty(tcx).sty {
-                    // FIXME: Why this does not work?
-                    // Some(adt_def.discr_ty.to_ty(tcx))
-                    let ty = match adt_def.discr_ty {
-                        attr::SignedInt(i) => tcx.mk_mach_int(i),
-                        attr::UnsignedInt(i) => tcx.mk_mach_uint(i),
-                    };
-                    Some(ty)
+                    Some(adt_def.discr_ty.to_ty(tcx))
                 } else {
                     None
                 }

src/librustc/ty/layout.rs

@@ -454,7 +454,7 @@ impl Integer {
     /// N.B.: u64 values above i64::MAX will be treated as signed, but
     /// that shouldn't affect anything, other than maybe debuginfo.
     pub fn repr_discr(tcx: TyCtxt, hints: &[attr::ReprAttr], min: i128, max: i128)
-    -> (Integer, bool) {
+                      -> (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

src/librustc/ty/util.rs

@@ -39,14 +39,14 @@ use rustc_i128::i128;
 use hir;
 
 pub trait IntTypeExt {
-    fn to_ty<'a, 'tcx>(self, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Ty<'tcx>;
+    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;
 }
 
 impl IntTypeExt for attr::IntType {
-    fn to_ty<'a, 'gcx, 'tcx>(self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Ty<'tcx> {
+    fn to_ty<'a, 'gcx: 'a+'tcx, 'tcx: 'a>(self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Ty<'tcx> {
         match self {
             SignedInt(i) => tcx.mk_mach_int(i),
             UnsignedInt(i) => tcx.mk_mach_uint(i),

src/librustc_borrowck/borrowck/mir/elaborate_drops.rs

@@ -706,8 +706,6 @@ impl<'b, 'tcx> ElaborateDropsCtxt<'b, 'tcx> {
                             switch_ty: discr_ty,
                             values: From::from(values),
                             targets: blocks,
-                            // adt_def: adt,
-                            // targets: variant_drops
                         }
                     }),
                     is_cleanup: c.is_cleanup,

src/librustc_mir/build/matches/test.rs

@@ -22,10 +22,10 @@ use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::bitvec::BitVector;
 use rustc::middle::const_val::{ConstVal, ConstInt};
 use rustc::ty::{self, Ty};
+use rustc::ty::util::IntTypeExt;
 use rustc::mir::*;
 use rustc::hir::RangeEnd;
 use syntax_pos::Span;
-use syntax::attr;
 use std::cmp::Ordering;
 
 impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
@@ -212,13 +212,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
                 }
                 debug!("num_enum_variants: {}, tested variants: {:?}, variants: {:?}",
                        num_enum_variants, values, variants);
-                // FIXME: WHY THIS DOES NOT WORK?!
-                // let discr_ty = adt_def.discr_ty.to_ty(tcx);
-                let discr_ty = match adt_def.discr_ty {
-                    attr::SignedInt(i) => tcx.mk_mach_int(i),
-                    attr::UnsignedInt(i) => tcx.mk_mach_uint(i),
-                };
-
+                let discr_ty = adt_def.discr_ty.to_ty(tcx);
                 let discr = self.temp(discr_ty);
                 self.cfg.push_assign(block, source_info, &discr,
                                      Rvalue::Discriminant(lvalue.clone()));

src/librustc_trans/mir/rvalue.rs

@@ -434,7 +434,6 @@ 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);
-                // FIXME: inline this
                 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)

src/librustc_typeck/collect.rs

@@ -1045,7 +1045,8 @@ fn evaluate_disr_expr(ccx: &CrateCtxt, repr_ty: attr::IntType, body: hir::BodyId
     let hint = UncheckedExprHint(ty_hint);
     match ConstContext::new(ccx.tcx, body).eval(e, hint) {
         Ok(ConstVal::Integral(i)) => {
-            // FIXME: eval should return an error if the hint is wrong
+            // FIXME: eval should return an error if the hint does not match the type of the body.
+            // i.e. eventually the match below would not exist.
             match (repr_ty, i) {
                 (attr::SignedInt(ast::IntTy::I8), ConstInt::I8(_)) |
                 (attr::SignedInt(ast::IntTy::I16), ConstInt::I16(_)) |