Add boolean constants as part of const_eval

Doesn't exactly eliminate a match check, but simplifies the logic a bit

Author: catamorphism

src/rustc/middle/check_alt.rs

@@ -1,6 +1,6 @@
 import syntax::ast::*;
 import syntax::ast_util::{variant_def_ids, dummy_sp, unguarded_pat};
-import const_eval::{eval_const_expr, const_val, const_int,
+import const_eval::{eval_const_expr, const_val, const_int, const_bool,
                     compare_const_vals};
 import syntax::codemap::span;
 import syntax::print::pprust::pat_to_str;
@@ -90,16 +90,19 @@ fn check_exhaustive(tcx: ty::ctxt, sp: span, pats: ~[@pat]) {
       useful(ty, ctor) => {
         match ty::get(ty).struct {
           ty::ty_bool => {
-            match check ctor {
-              val(const_int(1i64)) => some(~"true"),
-              val(const_int(0i64)) => some(~"false")
+            match ctor {
+              val(const_bool(true)) => some(~"true"),
+              val(const_bool(false)) => some(~"false"),
+              _ => none
             }
           }
           ty::ty_enum(id, _) => {
-            let vid = match check ctor { variant(id) => id };
-            match check vec::find(*ty::enum_variants(tcx, id),
+              let vid = match ctor { variant(id) => id,
+              _ => fail ~"check_exhaustive: non-variant ctor" };
+            match vec::find(*ty::enum_variants(tcx, id),
                                 |v| v.id == vid) {
-              some(v) => some(tcx.sess.str_of(v.name))
+                some(v) => some(tcx.sess.str_of(v.name)),
+              none => fail ~"check_exhaustive: bad variant in ctor"
             }
           }
           _ => none
@@ -152,10 +155,10 @@ fn is_useful(tcx: ty::ctxt, m: matrix, v: ~[@pat]) -> useful {
           none => {
             match ty::get(left_ty).struct {
               ty::ty_bool => {
-                match is_useful_specialized(tcx, m, v, val(const_int(1i64)),
+                match is_useful_specialized(tcx, m, v, val(const_bool(true)),
                                           0u, left_ty){
                   not_useful => {
-                    is_useful_specialized(tcx, m, v, val(const_int(0i64)),
+                    is_useful_specialized(tcx, m, v, val(const_bool(false)),
                                           0u, left_ty)
                   }
                   u => u
@@ -269,15 +272,16 @@ fn missing_ctor(tcx: ty::ctxt, m: matrix, left_ty: ty::t) -> option<ctor> {
       ty::ty_bool => {
         let mut true_found = false, false_found = false;
         for m.each |r| {
-            match check pat_ctor_id(tcx, r[0]) {
+            match pat_ctor_id(tcx, r[0]) {
               none => (),
-              some(val(const_int(1i64))) => true_found = true,
-              some(val(const_int(0i64))) => false_found = true
+              some(val(const_bool(true))) => true_found = true,
+              some(val(const_bool(false))) => false_found = true,
+              _ => fail ~"impossible case"
             }
         }
         if true_found && false_found { none }
-        else if true_found { some(val(const_int(0i64))) }
-        else { some(val(const_int(1i64))) }
+        else if true_found { some(val(const_bool(false))) }
+        else { some(val(const_bool(true))) }
       }
       _ => some(single)
     }
@@ -289,9 +293,11 @@ fn ctor_arity(tcx: ty::ctxt, ctor: ctor, ty: ty::t) -> uint {
       ty::ty_rec(fs) => fs.len(),
       ty::ty_box(_) | ty::ty_uniq(_) => 1u,
       ty::ty_enum(eid, _) => {
-        let id = match check ctor { variant(id) => id };
-        match check vec::find(*ty::enum_variants(tcx, eid), |v| v.id == id ) {
-          some(v) => v.args.len()
+          let id = match ctor { variant(id) => id,
+          _ => fail ~"impossible case" };
+        match vec::find(*ty::enum_variants(tcx, eid), |v| v.id == id ) {
+            some(v) => v.args.len(),
+            none => fail ~"impossible case"
         }
       }
       ty::ty_class(cid, _) => ty::lookup_class_fields(tcx, cid).len(),
@@ -319,20 +325,22 @@ fn specialize(tcx: ty::ctxt, r: ~[@pat], ctor_id: ctor, arity: uint,
         }
       }
       pat_enum(_, args) => {
-        match check tcx.def_map.get(r0.id) {
+        match tcx.def_map.get(r0.id) {
           def_variant(_, id) if variant(id) == ctor_id => {
             let args = match args {
               some(args) => args,
               none => vec::from_elem(arity, wild())
             };
             some(vec::append(args, vec::tail(r)))
           }
-          def_variant(_, _) => none
+          def_variant(_, _) => none,
+          _ => none
         }
       }
       pat_rec(flds, _) => {
-        let ty_flds = match check ty::get(left_ty).struct {
-          ty::ty_rec(flds) => flds
+        let ty_flds = match ty::get(left_ty).struct {
+            ty::ty_rec(flds) => flds,
+            _ => fail ~"bad type for pat_rec"
         };
         let args = vec::map(ty_flds, |ty_f| {
             match vec::find(flds, |f| f.ident == ty_f.ident ) {
@@ -367,21 +375,23 @@ fn specialize(tcx: ty::ctxt, r: ~[@pat], ctor_id: ctor, arity: uint,
       pat_box(a) | pat_uniq(a) => some(vec::append(~[a], vec::tail(r))),
       pat_lit(expr) => {
         let e_v = eval_const_expr(tcx, expr);
-        let match_ = match check ctor_id {
+        let match_ = match ctor_id {
           val(v) => compare_const_vals(e_v, v) == 0,
           range(c_lo, c_hi) => {
             compare_const_vals(c_lo, e_v) >= 0 &&
                 compare_const_vals(c_hi, e_v) <= 0
           }
-          single => true
+          single => true,
+          _ => fail ~"type error"
         };
         if match_ { some(vec::tail(r)) } else { none }
       }
       pat_range(lo, hi) => {
-        let (c_lo, c_hi) = match check ctor_id {
+        let (c_lo, c_hi) = match ctor_id {
           val(v) => (v, v),
           range(lo, hi) => (lo, hi),
           single => return some(vec::tail(r)),
+          _ => fail ~"type error"
         };
         let v_lo = eval_const_expr(tcx, lo),
             v_hi = eval_const_expr(tcx, hi);

src/rustc/middle/check_const.rs

@@ -182,10 +182,11 @@ fn check_item_recursion(sess: session, ast_map: ast_map::map,
           expr_path(path) => {
             match env.def_map.find(e.id) {
               some(def_const(def_id)) => {
-                match check env.ast_map.get(def_id.node) {
+                match env.ast_map.get(def_id.node) {
                   ast_map::node_item(it, _) => {
                     v.visit_item(it, env, v);
                   }
+                  _ => fail ~"const not bound to an item"
                 }
               }
               _ => ()

src/rustc/middle/const_eval.rs

@@ -186,30 +186,35 @@ enum const_val {
     const_int(i64),
     const_uint(u64),
     const_str(~str),
+    const_bool(bool)
 }
 
 // FIXME: issue #1417
 fn eval_const_expr(tcx: middle::ty::ctxt, e: @expr) -> const_val {
     import middle::ty;
     fn fromb(b: bool) -> const_val { const_int(b as i64) }
-    match check e.node {
+    match e.node {
       expr_unary(neg, inner) => {
-        match check eval_const_expr(tcx, inner) {
+        match eval_const_expr(tcx, inner) {
           const_float(f) => const_float(-f),
           const_int(i) => const_int(-i),
-          const_uint(i) => const_uint(-i)
+          const_uint(i) => const_uint(-i),
+          const_str(_) => fail ~"Negate on string",
+          const_bool(_) => fail ~"Negate on boolean"
         }
       }
       expr_unary(not, inner) => {
-        match check eval_const_expr(tcx, inner) {
+        match eval_const_expr(tcx, inner) {
           const_int(i) => const_int(!i),
-          const_uint(i) => const_uint(!i)
+          const_uint(i) => const_uint(!i),
+          const_bool(b) => const_bool(!b),
+          _ => fail ~"Not on float or string"
         }
       }
       expr_binary(op, a, b) => {
-        match check (eval_const_expr(tcx, a), eval_const_expr(tcx, b)) {
+        match (eval_const_expr(tcx, a), eval_const_expr(tcx, b)) {
           (const_float(a), const_float(b)) => {
-            match check op {
+            match op {
               add => const_float(a + b),
               subtract => const_float(a - b),
               mul => const_float(a * b),
@@ -220,11 +225,12 @@ fn eval_const_expr(tcx: middle::ty::ctxt, e: @expr) -> const_val {
               le => fromb(a <= b),
               ne => fromb(a != b),
               ge => fromb(a >= b),
-              gt => fromb(a > b)
+              gt => fromb(a > b),
+              _ => fail ~"Can't do this op on floats"
             }
           }
           (const_int(a), const_int(b)) => {
-            match check op {
+            match op {
               add => const_int(a + b),
               subtract => const_int(a - b),
               mul => const_int(a * b),
@@ -244,7 +250,7 @@ fn eval_const_expr(tcx: middle::ty::ctxt, e: @expr) -> const_val {
             }
           }
           (const_uint(a), const_uint(b)) => {
-            match check op {
+            match op {
               add => const_uint(a + b),
               subtract => const_uint(a - b),
               mul => const_uint(a * b),
@@ -260,54 +266,74 @@ fn eval_const_expr(tcx: middle::ty::ctxt, e: @expr) -> const_val {
               le => fromb(a <= b),
               ne => fromb(a != b),
               ge => fromb(a >= b),
-              gt => fromb(a > b)
+              gt => fromb(a > b),
             }
           }
           // shifts can have any integral type as their rhs
           (const_int(a), const_uint(b)) => {
-            match check op {
+            match op {
               shl => const_int(a << b),
-              shr => const_int(a >> b)
+              shr => const_int(a >> b),
+              _ => fail ~"Can't do this op on an int and uint"
             }
           }
           (const_uint(a), const_int(b)) => {
-            match check op {
+            match op {
               shl => const_uint(a << b),
-              shr => const_uint(a >> b)
+              shr => const_uint(a >> b),
+              _ => fail ~"Can't do this op on a uint and int"
             }
           }
+          (const_bool(a), const_bool(b)) => {
+            const_bool(match op {
+              and => a && b,
+              or => a || b,
+              bitxor => a ^ b,
+              bitand => a & b,
+              bitor => a | b,
+              eq => a == b,
+              ne => a != b,
+              _ => fail ~"Can't do this op on bools"
+             })
+          }
+          _ => fail ~"Bad operands for binary"
         }
       }
       expr_cast(base, _) => {
         let ety = ty::expr_ty(tcx, e);
         let base = eval_const_expr(tcx, base);
-        match check ty::get(ety).struct {
+        match ty::get(ety).struct {
           ty::ty_float(_) => {
-            match check base {
+            match base {
               const_uint(u) => const_float(u as f64),
               const_int(i) => const_float(i as f64),
-              const_float(_) => base
+              const_float(_) => base,
+              _ => fail ~"Can't cast float to str"
             }
           }
           ty::ty_uint(_) => {
-            match check base {
+            match base {
               const_uint(_) => base,
               const_int(i) => const_uint(i as u64),
-              const_float(f) => const_uint(f as u64)
+              const_float(f) => const_uint(f as u64),
+              _ => fail ~"Can't cast str to uint"
             }
           }
           ty::ty_int(_) | ty::ty_bool => {
-            match check base {
+            match base {
               const_uint(u) => const_int(u as i64),
               const_int(_) => base,
-              const_float(f) => const_int(f as i64)
+              const_float(f) => const_int(f as i64),
+              _ => fail ~"Can't cast str to int"
             }
           }
+          _ => fail ~"Can't cast this type"
         }
       }
       expr_lit(lit) => lit_to_const(lit),
       // If we have a vstore, just keep going; it has to be a string
-      expr_vstore(e, _) => eval_const_expr(tcx, e)
+      expr_vstore(e, _) => eval_const_expr(tcx, e),
+      _ => fail ~"Unsupported constant expr"
     }
 }
 
@@ -319,7 +345,7 @@ fn lit_to_const(lit: @lit) -> const_val {
       lit_int_unsuffixed(n) => const_int(n),
       lit_float(n, _) => const_float(option::get(float::from_str(*n)) as f64),
       lit_nil => const_int(0i64),
-      lit_bool(b) => const_int(b as i64)
+      lit_bool(b) => const_bool(b)
     }
 }
 
@@ -361,6 +387,15 @@ fn compare_const_vals(a: const_val, b: const_val) -> int {
             1
         }
     }
+    (const_bool(a), const_bool(b)) => {
+        if a == b {
+            0
+        } else if a < b {
+            -1
+        } else {
+            1
+        }
+    }
     _ => fail ~"compare_const_vals: ill-typed comparison"
   }
 }

src/rustc/middle/ty.rs

@@ -3379,6 +3379,13 @@ fn eval_repeat_count(tcx: ctxt, count_expr: @ast::expr, span: span) -> uint {
                                 repeat count but found string");
             return 0;
         }
+        const_eval::const_bool(_) => {
+            tcx.sess.span_err(span,
+                              ~"expected signed or unsigned integer for \
+                                repeat count but found boolean");
+            return 0;
+        }
+
     }
 }