auto merge of #11832 : jfager/rust/r5900, r=alexcrichton

I tried a couple of different ways to squash this, and still don't think this is ideal, but I wanted to get it out for feedback.

Closes #5900
Closes #9942

There are a few scenarios where the compiler tries to evaluate CastExprs without the corresponding types being available yet in the type context:  #10618, #5900, #9942

This PR takes the approach of having eval_const_expr_partial's CastExpr arm fall back to a limited ast_ty_to_ty call that only checks for (a subset of) valid const types, when the direct type lookup fails.  It's kind of hacky, so I understand if you don't want to take this as is.  I'd need a little mentoring to get this into better shape, as figuring out the proper fix has been a little daunting. I'm also happy if someone else wants to pick this up and run with it.

This closes 5900 and 9942, but only moves the goalposts a little on 10618, which now falls over in a later phase of the compiler.

Author: bors

src/librustc/middle/const_eval.rs

@@ -11,7 +11,9 @@
 
 use metadata::csearch;
 use middle::astencode;
+
 use middle::ty;
+use middle::typeck::astconv;
 use middle;
 
 use syntax::{ast, ast_map, ast_util};
@@ -445,8 +447,17 @@ pub fn eval_const_expr_partial<T: ty::ExprTyProvider>(tcx: &T, e: &Expr)
           _ => Err(~"Bad operands for binary")
         }
       }
-      ExprCast(base, _) => {
-        let ety = tcx.expr_ty(e);
+      ExprCast(base, target_ty) => {
+        // This tends to get called w/o the type actually having been
+        // populated in the ctxt, which was causing things to blow up
+        // (#5900). Fall back to doing a limited lookup to get past it.
+        let ety = ty::expr_ty_opt(tcx.ty_ctxt(), e)
+                .or_else(|| astconv::ast_ty_to_prim_ty(tcx.ty_ctxt(), target_ty))
+                .unwrap_or_else(|| tcx.ty_ctxt().sess.span_fatal(
+                    target_ty.span,
+                    format!("Target type not found for const cast")
+                ));
+
         let base = eval_const_expr_partial(tcx, base);
         match base {
             Err(_) => base,

src/librustc/middle/ty.rs

@@ -2669,17 +2669,24 @@ pub fn node_id_to_trait_ref(cx: ctxt, id: ast::NodeId) -> @ty::TraitRef {
 }
 
 pub fn node_id_to_type(cx: ctxt, id: ast::NodeId) -> t {
-    //printfln!("{:?}/{:?}", id, cx.node_types.len());
-    let node_types = cx.node_types.borrow();
-    match node_types.get().find(&(id as uint)) {
-       Some(&t) => t,
+    match node_id_to_type_opt(cx, id) {
+       Some(t) => t,
        None => cx.sess.bug(
            format!("node_id_to_type: no type for node `{}`",
                 ast_map::node_id_to_str(cx.items, id,
                                         token::get_ident_interner())))
     }
 }
 
+pub fn node_id_to_type_opt(cx: ctxt, id: ast::NodeId) -> Option<t> {
+    let node_types = cx.node_types.borrow();
+    debug!("id: {:?}, node_types: {:?}", id, node_types);
+    match node_types.get().find(&(id as uint)) {
+       Some(&t) => Some(t),
+       None => None
+    }
+}
+
 // FIXME(pcwalton): Makes a copy, bleh. Probably better to not do that.
 pub fn node_id_to_type_params(cx: ctxt, id: ast::NodeId) -> ~[t] {
     let node_type_substs = cx.node_type_substs.borrow();
@@ -2850,6 +2857,10 @@ pub fn expr_ty(cx: ctxt, expr: &ast::Expr) -> t {
     return node_id_to_type(cx, expr.id);
 }
 
+pub fn expr_ty_opt(cx: ctxt, expr: &ast::Expr) -> Option<t> {
+    return node_id_to_type_opt(cx, expr.id);
+}
+
 pub fn expr_ty_adjusted(cx: ctxt, expr: &ast::Expr) -> t {
     /*!
      *