Allow literal patterns to contain arbitrary literal expressions

This removes the need for the unary minus hacks, and allows some other
neat things like matching on 1 >> 4.

Issue #954

Author: marijnh

src/comp/driver/rustc.rs

@@ -137,6 +137,8 @@ fn compile_input(sess: session::session, cfg: ast::crate_cfg, input: str,
     let freevars =
         time(time_passes, "freevar finding",
              bind freevars::annotate_freevars(def_map, crate));
+    time(time_passes, "const checking",
+         bind middle::check_const::check_crate(sess, crate));
     let ty_cx = ty::mk_ctxt(sess, def_map, ext_map, ast_map, freevars);
     time(time_passes, "typechecking", bind typeck::check_crate(ty_cx, crate));
     time(time_passes, "block-use checking",
@@ -157,8 +159,6 @@ fn compile_input(sess: session::session, cfg: ast::crate_cfg, input: str,
         bind last_use::find_last_uses(crate, def_map, ref_map, ty_cx));
     time(time_passes, "kind checking",
          bind kind::check_crate(ty_cx, last_uses, crate));
-    time(time_passes, "const checking",
-         bind middle::check_const::check_crate(ty_cx, crate));
     if sess.get_opts().no_trans { ret; }
     let llmod =
         time(time_passes, "translation",

src/comp/middle/check_alt.rs

@@ -1,5 +1,6 @@
 import syntax::ast::*;
-import syntax::ast_util::{variant_def_ids, dummy_sp, compare_lit, lit_eq};
+import syntax::ast_util::{variant_def_ids, dummy_sp, compare_lit_exprs,
+                          lit_expr_eq};
 import syntax::visit;
 
 fn check_crate(tcx: ty::ctxt, crate: @crate) {
@@ -66,7 +67,7 @@ fn pattern_supersedes(tcx: ty::ctxt, a: @pat, b: @pat) -> bool {
       pat_wild. | pat_bind(_) { ret true; }
       pat_lit(la) {
         alt b.node {
-          pat_lit(lb) { ret lit_eq(la, lb); }
+          pat_lit(lb) { ret lit_expr_eq(la, lb); }
           _ { ret false; }
         }
       }
@@ -106,11 +107,12 @@ fn pattern_supersedes(tcx: ty::ctxt, a: @pat, b: @pat) -> bool {
       pat_range(begina, enda) {
         alt b.node {
           pat_lit(lb) {
-            ret compare_lit(begina, lb) <= 0 && compare_lit(enda, lb) >= 0;
+            ret compare_lit_exprs(begina, lb) <= 0 &&
+                compare_lit_exprs(enda, lb) >= 0;
           }
           pat_range(beginb, endb) {
-            ret compare_lit(begina, beginb) <= 0 &&
-                compare_lit(enda, endb) >= 0;
+            ret compare_lit_exprs(begina, beginb) <= 0 &&
+                compare_lit_exprs(enda, endb) >= 0;
           }
           _ { ret false; }
         }

src/comp/middle/check_const.rs

@@ -1,46 +1,61 @@
 import syntax::ast::*;
 import syntax::visit;
+import driver::session::session;
 
-fn check_crate(tcx: ty::ctxt, crate: @crate) {
-    let v =
-        @{visit_item: bind check_item(tcx, _, _, _)
-             with *visit::default_visitor::<()>()};
-    visit::visit_crate(*crate, (), visit::mk_vt(v));
-    tcx.sess.abort_if_errors();
+fn check_crate(sess: session, crate: @crate) {
+    visit::visit_crate(*crate, false, visit::mk_vt(@{
+        visit_item: check_item,
+        visit_pat: check_pat,
+        visit_expr: bind check_expr(sess, _, _, _)
+        with *visit::default_visitor()
+    }));
+    sess.abort_if_errors();
 }
 
-fn check_item(tcx: ty::ctxt, it: @item, &&s: (), v: visit::vt<()>) {
-    visit::visit_item(it, s, v);
+fn check_item(it: @item, &&_is_const: bool, v: visit::vt<bool>) {
     alt it.node {
-      item_const(_ /* ty */, ex) {
-         let v =
-             @{visit_expr: bind check_const_expr(tcx, _, _, _)
-                  with *visit::default_visitor::<()>()};
-         check_const_expr(tcx, ex, (), visit::mk_vt(v));
-       }
-       _ { }
+      item_const(_, ex) { v.visit_expr(ex, true, v); }
+      _ { visit::visit_item(it, false, v); }
     }
 }
 
-fn check_const_expr(tcx: ty::ctxt, ex: @expr, &&s: (), v: visit::vt<()>) {
-    visit::visit_expr(ex, s, v);
-    alt ex.node {
-      expr_lit(_) { }
-      expr_binary(_, _, _) { /* subexps covered by visit */ }
-      expr_unary(u, _) {
-        alt u {
-          box(_)  |
-          uniq(_) |
-          deref.  {
-            tcx.sess.span_err(ex.span,
-                              "disallowed operator in constant expression");
+fn check_pat(p: @pat, &&_is_const: bool, v: visit::vt<bool>) {
+    fn is_str(e: @expr) -> bool {
+        alt e.node { expr_lit(@{node: lit_str(_), _}) { true } _ { false } }
+    }
+    alt p.node {
+      // Let through plain string literals here
+      pat_lit(a) { if !is_str(a) { v.visit_expr(a, true, v); } }
+      pat_range(a, b) {
+        if !is_str(a) { v.visit_expr(a, true, v); }
+        if !is_str(b) { v.visit_expr(b, true, v); }
+      }
+      _ { visit::visit_pat(p, false, v); }
+    }
+}
+
+fn check_expr(sess: session, e: @expr, &&is_const: bool, v: visit::vt<bool>) {
+    if is_const {
+        alt e.node {
+          expr_unary(box(_), _) | expr_unary(uniq(_), _) |
+          expr_unary(deref., _){
+            sess.span_err(e.span,
+                          "disallowed operator in constant expression");
+            ret;
+          }
+          expr_lit(@{node: lit_str(_), _}) {
+            sess.span_err(e.span,
+                          "string constants are not supported");
+          }
+          expr_lit(_) | expr_binary(_, _, _) | expr_unary(_, _) {}
+          _ {
+            sess.span_err(e.span,
+                          "constant contains unimplemented expression type");
+            ret;
           }
-          _ { }
         }
-      }
-      _ { tcx.sess.span_err(ex.span,
-            "constant contains unimplemented expression type"); }
     }
+    visit::visit_expr(e, is_const, v);
 }
 
 // Local Variables:

src/comp/middle/trans_alt.rs

@@ -7,32 +7,27 @@ import trans_build::*;
 import trans::{new_sub_block_ctxt, new_scope_block_ctxt, load_if_immediate};
 import syntax::ast;
 import syntax::ast_util;
-import syntax::ast_util::{dummy_sp, lit_eq};
+import syntax::ast_util::{dummy_sp};
 import syntax::ast::def_id;
 import syntax::codemap::span;
 
 import trans_common::*;
 
 // An option identifying a branch (either a literal, a tag variant or a range)
 tag opt {
-    lit(@ast::lit);
+    lit(@ast::expr);
     var(/* variant id */uint, /* variant dids */{tg: def_id, var: def_id});
-    range(@ast::lit, @ast::lit);
+    range(@ast::expr, @ast::expr);
 }
 fn opt_eq(a: opt, b: opt) -> bool {
-    alt a {
-      lit(la) {
-        ret alt b { lit(lb) { lit_eq(la, lb) } _ { false } };
-      }
-      var(ida, _) {
-        ret alt b { var(idb, _) { ida == idb } _ { false } };
-      }
-      range(la1, la2) {
-        ret alt b {
-          range(lb1, lb2) { lit_eq(la1, lb1) && lit_eq(la2, lb2) }
-          _ { false }
-        };
+    alt (a, b) {
+      (lit(a), lit(b)) { ast_util::compare_lit_exprs(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
       }
+      (var(a, _), var(b, _)) { a == b }
+      _ { false }
     }
 }
 
@@ -45,7 +40,7 @@ fn trans_opt(bcx: @block_ctxt, o: opt) -> opt_result {
     alt o {
       lit(l) {
         alt l.node {
-          ast::lit_str(s) {
+          ast::expr_lit(@{node: ast::lit_str(s), _}) {
             let strty = ty::mk_str(bcx_tcx(bcx));
             let cell = trans::empty_dest_cell();
             bcx = trans_vec::trans_str(bcx, s, trans::by_val(cell));
@@ -54,17 +49,14 @@ fn trans_opt(bcx: @block_ctxt, o: opt) -> opt_result {
           }
           _ {
             ret single_result(
-                rslt(bcx, trans::trans_crate_lit(ccx, *l)));
+                rslt(bcx, trans::trans_const_expr(ccx, l)));
           }
         }
       }
       var(id, _) { ret single_result(rslt(bcx, C_int(ccx, id as int))); }
       range(l1, l2) {
-        let cell1 = trans::empty_dest_cell();
-        let cell2 = trans::empty_dest_cell();
-        let bcx = trans::trans_lit(bcx, *l1, trans::by_val(cell1));
-        let bcx = trans::trans_lit(bcx, *l2, trans::by_val(cell2));
-        ret range_result(rslt(bcx, *cell1), rslt(bcx, *cell2));
+        ret range_result(rslt(bcx, trans::trans_const_expr(ccx, l1)),
+                         rslt(bcx, trans::trans_const_expr(ccx, l2)));
       }
     }
 }
@@ -464,13 +456,9 @@ fn compile_submatch(bcx: @block_ctxt, m: match, vals: [ValueRef], f: mk_fail,
             }
           }
           lit(l) {
-            kind = alt l.node {
-              ast::lit_str(_) | ast::lit_nil. | ast::lit_float(_) |
-              ast::lit_mach_float(_, _) {
-                test_val = Load(bcx, val); compare
-              }
-              _ { test_val = Load(bcx, val); switch }
-            };
+            test_val = Load(bcx, val);
+            let pty = ty::node_id_to_monotype(ccx.tcx, pat_id);
+            kind = ty::type_is_integral(ccx.tcx, pty) ? switch : compare;
           }
           range(_, _) {
             test_val = Load(bcx, val);

src/comp/middle/ty.rs

@@ -155,6 +155,7 @@ export type_is_vec;
 export type_is_fp;
 export type_allows_implicit_copy;
 export type_is_integral;
+export type_is_numeric;
 export type_is_native;
 export type_is_nil;
 export type_is_pod;
@@ -1173,6 +1174,10 @@ fn type_is_fp(cx: ctxt, ty: t) -> bool {
     }
 }
 
+fn type_is_numeric(cx: ctxt, ty: t) -> bool {
+    ret type_is_integral(cx, ty) || type_is_fp(cx, ty);
+}
+
 fn type_is_signed(cx: ctxt, ty: t) -> bool {
     alt struct(cx, ty) {
       ty_int. { ret true; }

src/comp/middle/typeck.rs

@@ -1,7 +1,6 @@
 import syntax::{ast, ast_util};
 import ast::spanned;
-import syntax::ast_util::{local_def, respan, ty_param_kind, lit_is_numeric,
-                          lit_types_match};
+import syntax::ast_util::{local_def, respan, ty_param_kind};
 import syntax::visit;
 import metadata::csearch;
 import driver::session;
@@ -1253,8 +1252,8 @@ fn lit_as_float(l: @ast::lit) -> str {
     }
 }
 
-fn valid_range_bounds(l1: @ast::lit, l2: @ast::lit) -> bool {
-    ast_util::compare_lit(l1, l2) <= 0
+fn valid_range_bounds(from: @ast::expr, to: @ast::expr) -> bool {
+    ast_util::compare_lit_exprs(from, to) <= 0
 }
 
 // Pattern checking is top-down rather than bottom-up so that bindings get
@@ -1264,27 +1263,26 @@ fn check_pat(fcx: @fn_ctxt, map: ast_util::pat_id_map, pat: @ast::pat,
     alt pat.node {
       ast::pat_wild. { write::ty_only_fixup(fcx, pat.id, expected); }
       ast::pat_lit(lt) {
-        let typ = check_lit(fcx.ccx, lt);
-        typ = demand::simple(fcx, pat.span, expected, typ);
-        write::ty_only_fixup(fcx, pat.id, typ);
+        check_expr_with(fcx, lt, expected);
+        write::ty_only_fixup(fcx, pat.id, expr_ty(fcx.ccx.tcx, lt));
       }
       ast::pat_range(begin, end) {
-        if !lit_types_match(begin, end) {
+        check_expr_with(fcx, begin, expected);
+        check_expr_with(fcx, end, expected);
+        let b_ty = resolve_type_vars_if_possible(fcx, expr_ty(fcx.ccx.tcx,
+                                                              begin));
+        if b_ty != resolve_type_vars_if_possible(fcx, expr_ty(fcx.ccx.tcx,
+                                                              end)) {
             fcx.ccx.tcx.sess.span_err(pat.span, "mismatched types in range");
-        } else if !lit_is_numeric(begin) || !lit_is_numeric(end) {
+        } else if !ty::type_is_numeric(fcx.ccx.tcx, b_ty) {
             fcx.ccx.tcx.sess.span_err(pat.span,
                                       "non-numeric type used in range");
         } else if !valid_range_bounds(begin, end) {
             fcx.ccx.tcx.sess.span_err(begin.span,
                                       "lower range bound must be less \
                                        than upper");
         }
-        let typ1 = check_lit(fcx.ccx, begin);
-        typ1 = demand::simple(fcx, pat.span, expected, typ1);
-        write::ty_only_fixup(fcx, pat.id, typ1);
-        let typ2 = check_lit(fcx.ccx, end);
-        typ2 = demand::simple(fcx, pat.span, typ1, typ2);
-        write::ty_only_fixup(fcx, pat.id, typ2);
+        write::ty_only_fixup(fcx, pat.id, b_ty);
       }
       ast::pat_bind(name) {
         let vid = lookup_local(fcx, pat.span, pat.id);

src/comp/syntax/ast.rs

@@ -86,13 +86,13 @@ type field_pat = {ident: ident, pat: @pat};
 tag pat_ {
     pat_wild;
     pat_bind(ident);
-    pat_lit(@lit);
     pat_tag(@path, [@pat]);
     pat_rec([field_pat], bool);
     pat_tup([@pat]);
     pat_box(@pat);
     pat_uniq(@pat);
-    pat_range(@lit, @lit);
+    pat_lit(@expr);
+    pat_range(@expr, @expr);
 }
 
 tag mutability { mut; imm; maybe_mut; }