don't go through llvm for const indexing

references as first class const values

Author: Oliver Schneider

src/librustc/middle/const_eval.rs

@@ -207,7 +207,10 @@ pub enum const_val {
     const_binary(Rc<Vec<u8>>),
     const_bool(bool),
     Struct(ast::NodeId),
-    Tuple(ast::NodeId)
+    Tuple(ast::NodeId),
+    Array(ast::NodeId, u64),
+    Repeat(ast::NodeId, u64),
+    Ref(Box<const_val>),
 }
 
 pub fn const_expr_to_pat(tcx: &ty::ctxt, expr: &Expr, span: Span) -> P<ast::Pat> {
@@ -294,11 +297,28 @@ pub enum ErrKind {
     NegateOnBinary,
     NegateOnStruct,
     NegateOnTuple,
+    NegateOnArray,
+    NegateOnRepeat,
+    NegateOnRef,
     NotOnFloat,
     NotOnString,
     NotOnBinary,
     NotOnStruct,
     NotOnTuple,
+    NotOnArray,
+    NotOnRepeat,
+    NotOnRef,
+    
+    DerefInt,
+    DerefUInt,
+    DerefBool,
+    DerefString,
+    DerefFloat,
+    DerefBinary,
+    DerefTuple,
+    DerefStruct,
+    DerefArray,
+    DerefRepeat,
 
     NegateWithOverflow(i64),
     AddiWithOverflow(i64, i64),
@@ -318,6 +338,13 @@ pub enum ErrKind {
     ExpectedConstTuple,
     ExpectedConstStruct,
     TupleIndexOutOfBounds,
+    IndexedNonVec,
+    IndexNotNatural,
+    IndexNotInt,
+    IndexOutOfBounds,
+    RepeatCountNotNatural,
+    RepeatCountNotInt,
+	MutableRef,
 
     MiscBinaryOp,
     MiscCatchAll,
@@ -339,11 +366,28 @@ impl ConstEvalErr {
             NegateOnBinary => "negate on binary literal".into_cow(),
             NegateOnStruct => "negate on struct".into_cow(),
             NegateOnTuple => "negate on tuple".into_cow(),
+            NegateOnArray => "negate on array".into_cow(),
+            NegateOnRepeat => "negate on repeat".into_cow(),
+            NegateOnRef => "negate on ref".into_cow(),
             NotOnFloat => "not on float or string".into_cow(),
             NotOnString => "not on float or string".into_cow(),
             NotOnBinary => "not on binary literal".into_cow(),
             NotOnStruct => "not on struct".into_cow(),
             NotOnTuple => "not on tuple".into_cow(),
+            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(),
+            DerefFloat => "deref on float".into_cow(),
+            DerefString => "deref on string".into_cow(),
+            DerefBinary => "deref on binary literal".into_cow(),
+            DerefStruct => "deref on struct".into_cow(),
+            DerefTuple => "deref on tuple".into_cow(),
+            DerefArray => "deref on array".into_cow(),
+            DerefRepeat => "deref on repeat".into_cow(),
 
             NegateWithOverflow(..) => "attempted to negate with overflow".into_cow(),
             AddiWithOverflow(..) => "attempted to add with overflow".into_cow(),
@@ -363,6 +407,13 @@ impl ConstEvalErr {
             ExpectedConstTuple => "expected constant tuple".into_cow(),
             ExpectedConstStruct => "expected constant struct".into_cow(),
             TupleIndexOutOfBounds => "tuple index out of bounds".into_cow(),
+            IndexedNonVec => "indexing is only supported for arrays".into_cow(),
+            IndexNotNatural => "indices must be a natural number".into_cow(),
+            IndexNotInt => "indices must be integers".into_cow(),
+            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(),
 
             MiscBinaryOp => "bad operands for binary".into_cow(),
             MiscCatchAll => "unsupported constant expr".into_cow(),
@@ -682,6 +733,9 @@ pub fn eval_const_expr_partial<'tcx>(tcx: &ty::ctxt<'tcx>,
           const_binary(_) => signal!(e, NegateOnBinary),
           const_val::Tuple(_) => signal!(e, NegateOnTuple),
           const_val::Struct(..) => signal!(e, NegateOnStruct),
+          const_val::Array(..) => signal!(e, NegateOnArray),
+          const_val::Repeat(..) => signal!(e, NegateOnRepeat),
+          const_val::Ref(_) => signal!(e, NegateOnRef),
         }
       }
       ast::ExprUnary(ast::UnNot, ref inner) => {
@@ -694,6 +748,24 @@ pub fn eval_const_expr_partial<'tcx>(tcx: &ty::ctxt<'tcx>,
           const_binary(_) => signal!(e, NotOnBinary),
           const_val::Tuple(_) => signal!(e, NotOnTuple),
           const_val::Struct(..) => signal!(e, NotOnStruct),
+          const_val::Array(..) => signal!(e, NotOnArray),
+          const_val::Repeat(..) => signal!(e, NotOnRepeat),
+          const_val::Ref(_) => signal!(e, NotOnRef),
+        }
+      }
+      ast::ExprUnary(ast::UnDeref, ref inner) => {
+        match try!(eval_const_expr_partial(tcx, &**inner, ety)) {
+            const_int(_) => signal!(e, DerefInt),
+            const_uint(_) => signal!(e, DerefUInt),
+            const_bool(_) => signal!(e, DerefBool),
+            const_str(_) => signal!(e, DerefString),
+            const_float(_) => signal!(e, DerefFloat),
+            const_binary(_) => signal!(e, DerefBinary),
+            const_val::Tuple(_) => signal!(e, DerefTuple),
+            const_val::Struct(..) => signal!(e, DerefStruct),
+            const_val::Array(..) => signal!(e, DerefArray),
+            const_val::Repeat(..) => signal!(e, DerefRepeat),
+            const_val::Ref(inner) => *inner,
         }
       }
       ast::ExprBinary(op, ref a, ref b) => {
@@ -877,12 +949,54 @@ pub fn eval_const_expr_partial<'tcx>(tcx: &ty::ctxt<'tcx>,
       ast::ExprBlock(ref block) => {
         match block.expr {
             Some(ref expr) => try!(eval_const_expr_partial(tcx, &**expr, ety)),
-            None => const_int(0)
+            None => const_int(0) // huh???
         }
       }
       ast::ExprTup(_) => {
         const_val::Tuple(e.id)
       }
+      ast::ExprIndex(ref arr, ref idx) => {
+        let mut arr = try!(eval_const_expr_partial(tcx, arr, None));
+        while let const_val::Ref(inner) = arr {
+            arr = *inner;
+        }
+        let idx = try!(eval_const_expr_partial(tcx, idx, None));
+        let idx = match idx {
+            const_int(i) if i >= 0 => i as u64,
+            const_int(_) => signal!(e, IndexNotNatural),
+            const_uint(i) => i,
+            _ => signal!(e, IndexNotInt),
+        };
+        match arr {
+            const_val::Array(_, n) if idx >= n => signal!(e, IndexOutOfBounds),
+            const_val::Array(v, _) => if let ast::ExprVec(ref v) = tcx.map.expect_expr(v).node {
+                try!(eval_const_expr_partial(tcx, &*v[idx as usize], None))
+            } 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,
+             )),
+            _ => signal!(e, IndexedNonVec),
+        }
+      }
+      ast::ExprAddrOf(ast::Mutability::MutMutable, _) => signal!(e, MutableRef),
+      ast::ExprAddrOf(ast::Mutability::MutImmutable, ref expr) => {
+        const_val::Ref(Box::new(try!(eval_const_expr_partial(tcx, &**expr, None))))
+      },
+      ast::ExprVec(ref v) => const_val::Array(e.id, v.len() as u64),
+      ast::ExprRepeat(_, ref n) => const_val::Repeat(
+        e.id,
+        match try!(eval_const_expr_partial(tcx, &**n, None)) {
+            const_int(i) if i >= 0 => i as u64,
+            const_int(_) => signal!(e, RepeatCountNotNatural),
+            const_uint(i) => i,
+            _ => signal!(e, RepeatCountNotInt),
+        },
+      ),
       ast::ExprStruct(..) => {
         const_val::Struct(e.id)
       }

src/librustc/middle/ty.rs

@@ -6235,7 +6235,10 @@ pub fn eval_repeat_count(tcx: &ctxt, count_expr: &ast::Expr) -> usize {
                 const_eval::const_bool(_) => "boolean",
                 const_eval::const_binary(_) => "binary array",
                 const_eval::Struct(..) => "struct",
-                const_eval::Tuple(_) => "tuple"
+                const_eval::Tuple(_) => "tuple",
+                const_eval::Array(..) => "array",
+                const_eval::Repeat(..) => "repeat",
+                const_eval::Ref(_) => "ref",
             };
             span_err!(tcx.sess, count_expr.span, E0306,
                 "expected positive integer for repeat count, found {}",

src/librustc_trans/trans/common.rs

@@ -788,6 +788,10 @@ 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

@@ -34,11 +34,35 @@ use middle::ty::{self, Ty};
 use util::ppaux::{Repr, ty_to_string};
 
 use std::iter::repeat;
-use libc::c_uint;
 use syntax::{ast, ast_util};
 use syntax::parse::token;
 use syntax::ptr::P;
 
+fn const_val_for_idx<'a, 'tcx>(
+    cx: &CrateContext<'a, 'tcx>,
+    val: const_eval::const_val,
+    param_substs: &'tcx Substs<'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_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"),
+        const_eval::const_bool(b) => C_bool(cx, b),
+        const_eval::Struct(id) => id2val(id),
+        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),
+    }
+}
+
 pub fn const_lit(cx: &CrateContext, e: &ast::Expr, lit: &ast::Lit)
     -> ValueRef {
     let _icx = push_ctxt("trans_lit");
@@ -565,56 +589,16 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
               })
           }
 
-          ast::ExprIndex(ref base, ref index) => {
-              let (bv, bt) = const_expr(cx, &**base, param_substs);
-              let iv = match const_eval::eval_const_expr_partial(cx.tcx(), &**index, None) {
-                  Ok(const_eval::const_int(i)) => i as u64,
-                  Ok(const_eval::const_uint(u)) => u,
-                  _ => cx.sess().span_bug(index.span,
-                                          "index is not an integer-constant expression")
-              };
-              let (arr, len) = match bt.sty {
-                  ty::ty_vec(_, Some(u)) => (bv, C_uint(cx, u)),
-                  ty::ty_vec(_, None) | ty::ty_str => {
-                      let e1 = const_get_elt(cx, bv, &[0]);
-                      (const_deref_ptr(cx, e1), const_get_elt(cx, bv, &[1]))
-                  }
-                  ty::ty_rptr(_, mt) => match mt.ty.sty {
-                      ty::ty_vec(_, Some(u)) => {
-                          (const_deref_ptr(cx, bv), C_uint(cx, u))
-                      },
-                      _ => cx.sess().span_bug(base.span,
-                                              &format!("index-expr base must be a vector \
-                                                       or string type, found {}",
-                                                      ty_to_string(cx.tcx(), bt)))
-                  },
-                  _ => cx.sess().span_bug(base.span,
-                                          &format!("index-expr base must be a vector \
-                                                   or string type, found {}",
-                                                  ty_to_string(cx.tcx(), bt)))
-              };
+          ast::ExprIndex(..) => {
+            match const_eval::eval_const_expr_partial(cx.tcx(), &e, None) {
+                Ok(val) => const_val_for_idx(cx, val, param_substs),
+                Err(err) => cx.sess().span_fatal(
+                    e.span,
+                    &format!("constant indexing failed: {}", err.description()),
+                ),
+            }
+          },
 
-              let len = llvm::LLVMConstIntGetZExtValue(len) as u64;
-              let len = match bt.sty {
-                  ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty, ..}) => match ty.sty {
-                      ty::ty_str => {
-                          assert!(len > 0);
-                          len - 1
-                      }
-                      _ => len
-                  },
-                  _ => len
-              };
-              if iv >= len {
-                  // FIXME #3170: report this earlier on in the const-eval
-                  // pass. Reporting here is a bit late.
-                  cx.sess().span_err(e.span,
-                                     "const index-expr is out of bounds");
-                  C_undef(type_of::type_of(cx, bt).element_type())
-              } else {
-                  const_get_elt(cx, arr, &[iv as c_uint])
-              }
-          }
           ast::ExprCast(ref base, _) => {
             let llty = type_of::type_of(cx, ety);
             let (v, basety) = const_expr(cx, &**base, param_substs);

src/test/run-pass/array_const_index-0.rs

@@ -0,0 +1,14 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+static a: &'static [i32] = &[];
+static b: i32 = a[1];
+
+fn main() {}

src/test/run-pass/array_const_index-1.rs

@@ -0,0 +1,16 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+
+fn main() {
+    const arr: [i32; 6] = [42, 43, 44, 45, 46, 47];
+    const idx: usize = 3;
+    const val: i32 = arr[idx];
+}