undo hack and pure const eval of indices

Author: Oliver Schneider

src/librustc/middle/const_eval.rs

@@ -522,6 +522,15 @@ fn const_uint_not(a: u64, opt_ety: Option<UintTy>) -> const_val {
     const_uint(!a & mask)
 }
 
+pub fn eval_const_index(tcx: &ty::ctxt, idx: &Expr) -> Result<u64, ConstEvalErr> {
+    match try!(eval_const_expr_partial(tcx, idx, None)) {
+        const_int(i) if i >= 0 => Ok(i as u64),
+        const_int(_) => signal!(idx, IndexNotNatural),
+        const_uint(i) => Ok(i),
+        _ => signal!(idx, IndexNotInt),
+    }
+}
+
 macro_rules! overflow_checking_body {
     ($a:ident, $b:ident, $ety:ident, $overflowing_op:ident,
      lhs: $to_8_lhs:ident $to_16_lhs:ident $to_32_lhs:ident,
@@ -964,13 +973,7 @@ pub fn eval_const_expr_partial<'tcx>(tcx: &ty::ctxt<'tcx>,
         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),
-        };
+        let idx = try!(eval_const_index(tcx, idx));
         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 {

src/librustc_trans/trans/consts.rs

@@ -609,14 +609,56 @@ 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, ety),
-                Err(err) => cx.sess().span_fatal(
-                    e.span,
-                    &format!("constant indexing failed: {}", err.description()),
-                ),
-            }
+          ast::ExprIndex(ref base, ref index) => {
+              if let Ok(val) = const_eval::eval_const_expr_partial(cx.tcx(), &e, None) {
+                  const_val_for_idx(cx, val, param_substs, ety)
+              } else {
+                  let (bv, bt) = const_expr(cx, &**base, param_substs);
+                  let iv = try!(eval_const_index(tcx, idx));
+                  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)))
+                  };
+                  
+                  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.
+                      // Since some static-eval expressions aren't const-evaluable
+                      // this has to stay
+                      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, _) => {
@@ -693,40 +735,14 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                       _ => break,
                   }
               }
-              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")
+              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 {
-                  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")
-                  }
+                  // 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) => {