treat statics like consts during const eval + fix const integers

Author: Oliver Schneider

src/librustc/middle/const_eval.rs

@@ -308,7 +308,7 @@ pub enum ErrKind {
     NotOnArray,
     NotOnRepeat,
     NotOnRef,
-    
+
     DerefInt,
     DerefUInt,
     DerefBool,
@@ -344,7 +344,7 @@ pub enum ErrKind {
     IndexOutOfBounds,
     RepeatCountNotNatural,
     RepeatCountNotInt,
-	MutableRef,
+    MutableRef,
 
     MiscBinaryOp,
     MiscCatchAll,
@@ -377,7 +377,7 @@ impl ConstEvalErr {
             NotOnArray => "not on array".into_cow(),
             NotOnRepeat => "not on repeat".into_cow(),
             NotOnRef => "not on ref".into_cow(),
-            
+
             DerefInt => "deref on int".into_cow(),
             DerefUInt => "deref on unsigned int".into_cow(),
             DerefBool => "deref on float".into_cow(),
@@ -413,7 +413,7 @@ impl ConstEvalErr {
             IndexOutOfBounds => "array index out of bounds".into_cow(),
             RepeatCountNotNatural => "repeat count must be a natural number".into_cow(),
             RepeatCountNotInt => "repeat count must be integers".into_cow(),
-			MutableRef => "cannot get a mutable reference to a constant".into_cow(),
+            MutableRef => "cannot get a mutable reference to a constant".into_cow(),
 
             MiscBinaryOp => "bad operands for binary".into_cow(),
             MiscCatchAll => "unsupported constant expr".into_cow(),
@@ -887,13 +887,17 @@ pub fn eval_const_expr_partial<'tcx>(tcx: &ty::ctxt<'tcx>,
       ast::ExprPath(..) => {
           let opt_def = tcx.def_map.borrow().get(&e.id).map(|d| d.full_def());
           let (const_expr, const_ty) = match opt_def {
-              Some(def::DefConst(def_id)) => {
+              Some(def::DefConst(def_id))
+              | Some(def::DefStatic(def_id, false)) => {
                   if ast_util::is_local(def_id) {
                       match tcx.map.find(def_id.node) {
                           Some(ast_map::NodeItem(it)) => match it.node {
                               ast::ItemConst(ref ty, ref expr) => {
                                   (Some(&**expr), Some(&**ty))
                               }
+                              ast::ItemStatic(ref ty, ast::MutImmutable, ref expr) => {
+                                  (Some(&**expr), Some(&**ty))
+                              }
                               _ => (None, None)
                           },
                           _ => (None, None)
@@ -974,12 +978,21 @@ pub fn eval_const_expr_partial<'tcx>(tcx: &ty::ctxt<'tcx>,
             } else {
                 unreachable!()
             },
+
             const_val::Repeat(_, n) if idx >= n => signal!(e, IndexOutOfBounds),
             const_val::Repeat(elem, _) => try!(eval_const_expr_partial(
                 tcx,
                 &*tcx.map.expect_expr(elem),
                 None,
-             )),
+            )),
+
+            const_val::const_binary(ref data) if idx as usize >= data.len()
+                => signal!(e, IndexOutOfBounds),
+            const_val::const_binary(data) => const_val::const_uint(data[idx as usize] as u64),
+
+            const_val::const_str(ref s) if idx as usize >= s.len()
+                => signal!(e, IndexOutOfBounds),
+            const_val::const_str(_) => unimplemented!(), // there's no const_char type
             _ => signal!(e, IndexedNonVec),
         }
       }

src/librustc_trans/trans/common.rs

@@ -788,10 +788,6 @@ pub fn C_u64(ccx: &CrateContext, i: u64) -> ValueRef {
     C_integral(Type::i64(ccx), i, false)
 }
 
-pub fn C_i64(ccx: &CrateContext, i: i64) -> ValueRef {
-    C_integral(Type::i64(ccx), i as u64, true)
-}
-
 pub fn C_int<I: AsI64>(ccx: &CrateContext, i: I) -> ValueRef {
     let v = i.as_i64();
 

src/librustc_trans/trans/consts.rs

@@ -43,15 +43,34 @@ fn const_val_for_idx<'a, 'tcx>(
     cx: &CrateContext<'a, 'tcx>,
     val: const_eval::const_val,
     param_substs: &'tcx Substs<'tcx>,
+    ety: Ty<'tcx>,
     ) -> ValueRef
 {
     let id2val = |id| {
         let expr = cx.tcx().map.expect_expr(id);
         const_expr(cx, expr, param_substs).0
     };
     match val {
-        const_eval::const_int(i) => C_i64(cx, i), // this might be wrong
-        const_eval::const_uint(u) => C_u64(cx, u), // this too
+        const_eval::const_int(i) => if let ty::ty_int(t) = ety.sty {
+            C_integral(Type::int_from_ty(cx, t), i as u64, true)
+        } else {
+            cx.sess().bug(
+                &format!(
+                    "integer literal has type {}",
+                    ty_to_string(cx.tcx(), ety),
+                )
+            )
+        },
+        const_eval::const_uint(u) =>  if let ty::ty_uint(t) = ety.sty {
+            C_integral(Type::uint_from_ty(cx, t), u as u64, false)
+        } else {
+            cx.sess().bug(
+                &format!(
+                    "unsigned integer literal has type {}",
+                    ty_to_string(cx.tcx(), ety),
+                )
+            )
+        },
         const_eval::const_float(f) => C_floating(&f.to_string(), Type::f64(cx)),
         const_eval::const_str(s) => C_str_slice(cx, s),
         const_eval::const_binary(data) => addr_of(cx, C_bytes(cx, &data[..]), "binary"),
@@ -60,7 +79,7 @@ fn const_val_for_idx<'a, 'tcx>(
         const_eval::Tuple(id) => id2val(id),
         const_eval::Array(id, _) => id2val(id),
         const_eval::Repeat(id, _) => id2val(id),
-        const_eval::Ref(inner) => const_val_for_idx(cx, *inner, param_substs),
+        const_eval::Ref(inner) => const_val_for_idx(cx, *inner, param_substs, ety),
     }
 }
 
@@ -592,7 +611,7 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
 
           ast::ExprIndex(..) => {
             match const_eval::eval_const_expr_partial(cx.tcx(), &e, None) {
-                Ok(val) => const_val_for_idx(cx, val, param_substs),
+                Ok(val) => const_val_for_idx(cx, val, param_substs, ety),
                 Err(err) => cx.sess().span_fatal(
                     e.span,
                     &format!("constant indexing failed: {}", err.description()),

src/test/run-pass/array_const_index-0.rs renamed to src/test/compile-fail/array_const_index-0.rs

@@ -9,6 +9,6 @@
 // except according to those terms.
 
 static a: &'static [i32] = &[];
-static b: i32 = a[1];
+static b: i32 = (&a)[1]; //~ ERROR: constant indexing failed: array index out of bounds
 
-fn main() {}
+fn main() {}

src/test/compile-fail/const-array-oob.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 const FOO: [u32; 3] = [1, 2, 3];
-const BAR: u32 = FOO[5]; //~ ERROR const index-expr is out of bounds
+const BAR: u32 = FOO[5]; //~ ERROR constant indexing failed: array index out of bounds
 
 fn main() {
     let _ = BAR;

src/test/run-pass/check-static-slice.rs

@@ -19,14 +19,14 @@ const AD: &'static [isize] = &AA;
 const AE: &'static [isize; 3] = &[1, 2, 3];
 const AF: &'static [isize] = &[1, 2, 3];
 
-const CA: isize = AA[0];
-const CB: isize = AB[1];
-const CC: isize = AC[2];
-const CD: isize = AD[0];
-const CE: isize = AE[1];
-const CF: isize = AF[2];
+static CA: isize = AA[0];
+static CB: isize = AB[1];
+static CC: isize = AC[2];
+static CD: isize = AD[0];
+static CE: isize = AE[1];
+static CF: isize = AF[2];
 
-const AG: &'static isize = &AA[2];
+static AG: &'static isize = &AA[2];
 
 fn main () {
     let b: &[isize] = &[1, 2, 3];

src/test/run-pass/const-enum-vec-index.rs

@@ -13,9 +13,9 @@ enum E { V1(isize), V0 }
 const C: &'static [E] = &[E::V0, E::V1(0xDEADBEE)];
 static C0: E = C[0];
 static C1: E = C[1];
-const D: &'static [E; 2] = &[E::V0, E::V1(0xDEADBEE)];
-static D0: E = C[0];
-static D1: E = C[1];
+const D: &'static [E; 2] = &[E::V0, E::V1(0xDEAFBEE)];
+static D0: E = D[0];
+static D1: E = D[1];
 
 pub fn main() {
     match C0 {
@@ -32,7 +32,7 @@ pub fn main() {
         _ => panic!()
     }
     match D1 {
-        E::V1(n) => assert!(n == 0xDEADBEE),
+        E::V1(n) => assert!(n == 0xDEAFBEE),
         _ => panic!()
     }
 }

src/test/run-pass/const-str-ptr.rs

@@ -18,6 +18,7 @@ const C: *const u8 = B as *const u8;
 pub fn main() {
     unsafe {
         let foo = &A as *const u8;
+        assert_eq!(foo, C);
         assert_eq!(str::from_utf8_unchecked(&A), "hi");
         assert!(*C == A[0]);
         assert!(*(&B[0] as *const u8) == A[0]);