ups

Author: Oliver Schneider

src/librustc_trans/trans/consts.rs

@@ -610,54 +610,59 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
           }
 
           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)))
+              match const_eval::eval_const_expr_partial(cx.tcx(), &e, None) {
+                  Ok(val) => const_val_for_idx(cx, val, param_substs, ety),
+                  Err(NonConstPath) => {
+              let (bv, bt) = const_expr(cx, &**base, param_substs);
+              let iv = try!(const_eval::eval_const_index(cx.tcx(), index));
+              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)))
-                  };
-                  
-                  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
-                      },
+                  },
+                  _ => 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
-                  };
-                  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])
-                  }
+                  },
+                  _ => 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])
+              }
+                  },
+                  Err(err) => cx.sess().span_fatal(
+                      e.span,
+                      &format!("constant indexing failed: {}", err.description()),
+                  ),
               }
           },