---

yaml
---
r: 14840
b: refs/heads/try
c: de79caa
h: refs/heads/master
v: v3

Author: marijnh

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: c988800cf5611130e468761caa4d2f5adbdc6781
+refs/heads/try: de79caa97ebfb86adaaae1c54237a94a610f94c0
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/src/rustc/driver/driver.rs

@@ -148,7 +148,8 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
         time(time_passes, "typechecking",
              bind typeck::check_crate(ty_cx, impl_map, crate));
     time(time_passes, "const checking",
-         bind middle::check_const::check_crate(sess, crate, method_map));
+         bind middle::check_const::check_crate(sess, crate, method_map,
+                                               ty_cx));
 
     if upto == cu_typeck { ret {crate: crate, tcx: some(ty_cx)}; }
 

branches/try/src/rustc/middle/check_alt.rs

@@ -258,19 +258,19 @@ fn pattern_supersedes(tcx: ty::ctxt, a: @pat, b: @pat) -> bool {
       }
       pat_lit(la) {
         alt b.node {
-          pat_lit(lb) { lit_expr_eq(la, lb) }
+          pat_lit(lb) { lit_expr_eq(tcx, la, lb) }
           _ { false }
         }
       }
       pat_range(begina, enda) {
         alt b.node {
           pat_lit(lb) {
-            compare_lit_exprs(begina, lb) <= 0 &&
-            compare_lit_exprs(enda, lb) >= 0
+            compare_lit_exprs(tcx, begina, lb) <= 0 &&
+            compare_lit_exprs(tcx, enda, lb) >= 0
           }
           pat_range(beginb, endb) {
-            compare_lit_exprs(begina, beginb) <= 0 &&
-            compare_lit_exprs(enda, endb) >= 0
+            compare_lit_exprs(tcx, begina, beginb) <= 0 &&
+            compare_lit_exprs(tcx, enda, endb) >= 0
           }
           _ { false }
         }

branches/try/src/rustc/middle/check_const.rs

@@ -3,11 +3,12 @@ import syntax::{visit, ast_util};
 import driver::session::session;
 import std::map::hashmap;
 
-fn check_crate(sess: session, crate: @crate, method_map: typeck::method_map) {
+fn check_crate(sess: session, crate: @crate, method_map: typeck::method_map,
+               tcx: ty::ctxt) {
     visit::visit_crate(*crate, false, visit::mk_vt(@{
         visit_item: check_item,
         visit_pat: check_pat,
-        visit_expr: bind check_expr(sess, method_map, _, _, _)
+        visit_expr: bind check_expr(sess, method_map, tcx, _, _, _)
         with *visit::default_visitor()
     }));
     sess.abort_if_errors();
@@ -42,8 +43,8 @@ fn check_pat(p: @pat, &&_is_const: bool, v: visit::vt<bool>) {
     }
 }
 
-fn check_expr(sess: session, method_map: typeck::method_map, e: @expr,
-              &&is_const: bool, v: visit::vt<bool>) {
+fn check_expr(sess: session, method_map: typeck::method_map, tcx: ty::ctxt,
+              e: @expr, &&is_const: bool, v: visit::vt<bool>) {
     if is_const {
         alt e.node {
           expr_unary(box(_), _) | expr_unary(uniq(_), _) |
@@ -63,6 +64,14 @@ fn check_expr(sess: session, method_map: typeck::method_map, e: @expr,
             }
           }
           expr_lit(_) {}
+          expr_cast(_, _) {
+            let ety = ty::expr_ty(tcx, e);
+            if !ty::type_is_numeric(ety) {
+                sess.span_err(e.span, "can not cast to `" +
+                              util::ppaux::ty_to_str(tcx, ety) +
+                              "` in a constant expression");
+            }
+          }
           _ {
             sess.span_err(e.span,
                           "constant contains unimplemented expression type");

branches/try/src/rustc/middle/trans/alt.rs

@@ -23,12 +23,12 @@ enum opt {
     var(/* disr val */int, /* variant dids */{enm: def_id, var: def_id}),
     range(@ast::expr, @ast::expr)
 }
-fn opt_eq(a: opt, b: opt) -> bool {
+fn opt_eq(tcx: ty::ctxt, a: opt, b: opt) -> bool {
     alt (a, b) {
-      (lit(a), lit(b)) { ast_util::compare_lit_exprs(a, b) == 0 }
+      (lit(a), lit(b)) { ast_util::compare_lit_exprs(tcx, a, b) == 0 }
       (range(a1, a2), range(b1, b2)) {
-        ast_util::compare_lit_exprs(a1, b1) == 0 &&
-        ast_util::compare_lit_exprs(a2, b2) == 0
+        ast_util::compare_lit_exprs(tcx, a1, b1) == 0 &&
+        ast_util::compare_lit_exprs(tcx, a2, b2) == 0
       }
       (var(a, _), var(b, _)) { a == b }
       _ { false }
@@ -161,18 +161,18 @@ fn enter_opt(tcx: ty::ctxt, m: match, opt: opt, col: uint,
     enter_match(tcx.def_map, m, col, val) {|p|
         alt p.node {
           ast::pat_enum(_, subpats) {
-            if opt_eq(variant_opt(tcx, p.id), opt) { some(subpats) }
+            if opt_eq(tcx, variant_opt(tcx, p.id), opt) { some(subpats) }
             else { none }
           }
           ast::pat_ident(_, none) if pat_is_variant(tcx.def_map, p) {
-            if opt_eq(variant_opt(tcx, p.id), opt) { some([]) }
+            if opt_eq(tcx, variant_opt(tcx, p.id), opt) { some([]) }
             else { none }
           }
           ast::pat_lit(l) {
-            if opt_eq(lit(l), opt) { some([]) } else { none }
+            if opt_eq(tcx, lit(l), opt) { some([]) } else { none }
           }
           ast::pat_range(l1, l2) {
-            if opt_eq(range(l1, l2), opt) { some([]) } else { none }
+            if opt_eq(tcx, range(l1, l2), opt) { some([]) } else { none }
           }
           _ { some(vec::from_elem(variant_size, dummy)) }
         }
@@ -232,21 +232,21 @@ fn enter_uniq(dm: def_map, m: match, col: uint, val: ValueRef) -> match {
 }
 
 fn get_options(ccx: crate_ctxt, m: match, col: uint) -> [opt] {
-    fn add_to_set(&set: [opt], val: opt) {
-        for l in set { if opt_eq(l, val) { ret; } }
+    fn add_to_set(tcx: ty::ctxt, &set: [opt], val: opt) {
+        for l in set { if opt_eq(tcx, l, val) { ret; } }
         set += [val];
     }
 
     let found = [];
     for br in m {
         let cur = br.pats[col];
         if pat_is_variant(ccx.tcx.def_map, cur) {
-            add_to_set(found, variant_opt(ccx.tcx, br.pats[col].id));
+            add_to_set(ccx.tcx, found, variant_opt(ccx.tcx, br.pats[col].id));
         } else {
             alt cur.node {
-              ast::pat_lit(l) { add_to_set(found, lit(l)); }
+              ast::pat_lit(l) { add_to_set(ccx.tcx, found, lit(l)); }
               ast::pat_range(l1, l2) {
-                add_to_set(found, range(l1, l2));
+                add_to_set(ccx.tcx, found, range(l1, l2));
               }
               _ {}
             }

branches/try/src/rustc/middle/trans/base.rs

@@ -2592,6 +2592,17 @@ fn float_cast(bcx: block, lldsttype: TypeRef, llsrctype: TypeRef,
         } else { llsrc };
 }
 
+enum cast_kind { cast_pointer, cast_integral, cast_float,
+                 cast_enum, cast_other, }
+fn cast_type_kind(t: ty::t) -> cast_kind {
+    if ty::type_is_fp(t) { cast_float }
+    else if ty::type_is_unsafe_ptr(t) { cast_pointer }
+    else if ty::type_is_integral(t) { cast_integral }
+    else if ty::type_is_enum(t) { cast_enum }
+    else { cast_other }
+}
+
+
 fn trans_cast(cx: block, e: @ast::expr, id: ast::node_id,
               dest: dest) -> block {
     let ccx = cx.ccx();
@@ -2605,55 +2616,48 @@ fn trans_cast(cx: block, e: @ast::expr, id: ast::node_id,
     let t_in = expr_ty(cx, e);
     let ll_t_out = type_of(ccx, t_out);
 
-    enum kind { pointer, integral, float, enum_, other, }
-    fn t_kind(t: ty::t) -> kind {
-        ret if ty::type_is_fp(t) { float }
-        else if ty::type_is_unsafe_ptr(t) { pointer }
-        else if ty::type_is_integral(t) { integral }
-        else if ty::type_is_enum(t) { enum_ }
-        else { other };
-    }
-    let k_in = t_kind(t_in);
-    let k_out = t_kind(t_out);
-    let s_in = k_in == integral && ty::type_is_signed(t_in);
+    let k_in = cast_type_kind(t_in);
+    let k_out = cast_type_kind(t_out);
+    let s_in = k_in == cast_integral && ty::type_is_signed(t_in);
 
     let newval =
         alt {in: k_in, out: k_out} {
-          {in: integral, out: integral} {
+          {in: cast_integral, out: cast_integral} {
             int_cast(e_res.bcx, ll_t_out, ll_t_in, e_res.val, s_in)
           }
-          {in: float, out: float} {
+          {in: cast_float, out: cast_float} {
             float_cast(e_res.bcx, ll_t_out, ll_t_in, e_res.val)
           }
-          {in: integral, out: float} {
+          {in: cast_integral, out: cast_float} {
             if s_in {
                 SIToFP(e_res.bcx, e_res.val, ll_t_out)
             } else { UIToFP(e_res.bcx, e_res.val, ll_t_out) }
           }
-          {in: float, out: integral} {
+          {in: cast_float, out: cast_integral} {
             if ty::type_is_signed(t_out) {
                 FPToSI(e_res.bcx, e_res.val, ll_t_out)
             } else { FPToUI(e_res.bcx, e_res.val, ll_t_out) }
           }
-          {in: integral, out: pointer} {
+          {in: cast_integral, out: cast_pointer} {
             IntToPtr(e_res.bcx, e_res.val, ll_t_out)
           }
-          {in: pointer, out: integral} {
+          {in: cast_pointer, out: cast_integral} {
             PtrToInt(e_res.bcx, e_res.val, ll_t_out)
           }
-          {in: pointer, out: pointer} {
+          {in: cast_pointer, out: cast_pointer} {
             PointerCast(e_res.bcx, e_res.val, ll_t_out)
           }
-          {in: enum_, out: integral} | {in: enum_, out: float} {
+          {in: cast_enum, out: cast_integral} |
+          {in: cast_enum, out: cast_float} {
             let cx = e_res.bcx;
             let llenumty = T_opaque_enum_ptr(ccx);
             let av_enum = PointerCast(cx, e_res.val, llenumty);
             let lldiscrim_a_ptr = GEPi(cx, av_enum, [0, 0]);
             let lldiscrim_a = Load(cx, lldiscrim_a_ptr);
             alt k_out {
-              integral {int_cast(e_res.bcx, ll_t_out,
-                                  val_ty(lldiscrim_a), lldiscrim_a, true)}
-              float {SIToFP(e_res.bcx, lldiscrim_a, ll_t_out)}
+              cast_integral {int_cast(e_res.bcx, ll_t_out,
+                                      val_ty(lldiscrim_a), lldiscrim_a, true)}
+              cast_float {SIToFP(e_res.bcx, lldiscrim_a, ll_t_out)}
               _ { ccx.sess.bug("translating unsupported cast.") }
             }
           }
@@ -4335,6 +4339,26 @@ fn trans_const_expr(cx: crate_ctxt, e: @ast::expr) -> ValueRef {
           }
         }
       }
+      ast::expr_cast(base, tp) {
+        let ety = ty::expr_ty(cx.tcx, e), llty = type_of(cx, ety);
+        let basety = ty::expr_ty(cx.tcx, base);
+        let v = trans_const_expr(cx, base);
+        alt check (cast_type_kind(basety), cast_type_kind(ety)) {
+          (cast_integral, cast_integral) {
+            let s = if ty::type_is_signed(basety) { True } else { False };
+            llvm::LLVMConstIntCast(v, llty, s)
+          }
+          (cast_integral, cast_float) {
+            if ty::type_is_signed(basety) { llvm::LLVMConstSIToFP(v, llty) }
+            else { llvm::LLVMConstUIToFP(v, llty) }
+          }
+          (cast_float, cast_float) { llvm::LLVMConstFPCast(v, llty) }
+          (cast_float, cast_integral) {
+            if ty::type_is_signed(ety) { llvm::LLVMConstFPToSI(v, llty) }
+            else { llvm::LLVMConstFPToUI(v, llty) }
+          }
+        }
+      }
       _ { cx.sess.span_bug(e.span,
             "bad constant expression type in trans_const_expr"); }
     }

branches/try/src/rustc/middle/ty.rs

@@ -2373,7 +2373,7 @@ fn enum_variants(cx: ctxt, id: ast::def_id) -> @[variant_info] {
                 alt variant.node.disr_expr {
                   some (ex) {
                     // FIXME: issue #1417
-                    disr_val = alt syntax::ast_util::eval_const_expr(ex) {
+                    disr_val = alt syntax::ast_util::eval_const_expr(cx, ex) {
                       ast_util::const_int(val) {val as int}
                       _ { cx.sess.bug("tag_variants: bad disr expr"); }
                     }

branches/try/src/rustc/middle/typeck.rs

@@ -1437,8 +1437,9 @@ fn check_lit(ccx: @crate_ctxt, lit: @ast::lit) -> ty::t {
     }
 }
 
-fn valid_range_bounds(from: @ast::expr, to: @ast::expr) -> bool {
-    ast_util::compare_lit_exprs(from, to) <= 0
+fn valid_range_bounds(tcx: ty::ctxt, from: @ast::expr, to: @ast::expr)
+    -> bool {
+    ast_util::compare_lit_exprs(tcx, from, to) <= 0
 }
 
 fn check_pat_variant(fcx: @fn_ctxt, map: pat_util::pat_id_map,
@@ -1516,7 +1517,7 @@ fn check_pat(fcx: @fn_ctxt, map: pat_util::pat_id_map, pat: @ast::pat,
             tcx.sess.span_err(pat.span, "mismatched types in range");
         } else if !ty::type_is_numeric(b_ty) {
             tcx.sess.span_err(pat.span, "non-numeric type used in range");
-        } else if !valid_range_bounds(begin, end) {
+        } else if !valid_range_bounds(tcx, begin, end) {
             tcx.sess.span_err(begin.span, "lower range bound must be less \
                                            than upper");
         }
@@ -2913,14 +2914,14 @@ fn check_enum_variants(ccx: @crate_ctxt, sp: span, vs: [ast::variant],
         alt v.node.disr_expr {
           some(e) {
             check_expr(fcx, e);
-            let cty = expr_ty(fcx.ccx.tcx, e);
-            let declty = ty::mk_int(fcx.ccx.tcx);
+            let cty = expr_ty(ccx.tcx, e);
+            let declty = ty::mk_int(ccx.tcx);
             demand::simple(fcx, e.span, declty, cty);
             // FIXME: issue #1417
             // Also, check_expr (from check_const pass) doesn't guarantee that
             // the expression in an form that eval_const_expr can handle, so
             // we may still get an internal compiler error
-            alt syntax::ast_util::eval_const_expr(e) {
+            alt syntax::ast_util::eval_const_expr(ccx.tcx, e) {
               syntax::ast_util::const_int(val) {
                 disr_val = val as int;
               }