static ref special case for indexing

all other indexing is by-val in const_eval_partial

Author: Oliver Schneider

src/librustc_trans/trans/consts.rs

@@ -34,6 +34,7 @@ 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;
@@ -673,14 +674,40 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                       _ => break,
                   }
               }
-              let opt_def = cx.tcx().def_map.borrow().get(&cur.id).map(|d| d.full_def());
-              if let Some(def::DefStatic(def_id, _)) = opt_def {
-                  get_static_val(cx, def_id, ety)
-              } else {
-                  // If this isn't the address of a static, then keep going through
-                  // normal constant evaluation.
-                  let (v, _) = const_expr(cx, &**sub, param_substs);
+              if let ast::ExprIndex(ref base, ref index) = cur.node {
+                  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,
+                      _ => unreachable!(),
+                  };
+                  let arr = match bt.sty {
+                      ty::ty_vec(_, Some(_)) => bv,
+                      ty::ty_vec(_, None) | ty::ty_str => {
+                          let e1 = const_get_elt(cx, bv, &[0]);
+                          const_deref_ptr(cx, e1)
+                      },
+                      ty::ty_rptr(_, mt) => if let ty::ty_vec(_, Some(_)) = mt.ty.sty {
+                          const_deref_ptr(cx,bv)
+                      } else {
+                          unreachable!()
+                      },
+                      _ => unreachable!(),
+                  };
+                  // UB if const_eval wasn't called on this
+                  // since no len check happening here
+                  let v = const_get_elt(cx, arr, &[iv as c_uint]);
                   addr_of(cx, v, "ref")
+              } else {
+                  let opt_def = cx.tcx().def_map.borrow().get(&cur.id).map(|d| d.full_def());
+                  if let Some(def::DefStatic(def_id, _)) = opt_def {
+                      get_static_val(cx, def_id, ety)
+                  } else {
+                      // If this isn't the address of a static, then keep going through
+                      // normal constant evaluation.
+                      let (v, _) = const_expr(cx, &**sub, param_substs);
+                      addr_of(cx, v, "ref")
+                  }
               }
           }
           ast::ExprAddrOf(ast::MutMutable, ref sub) => {