Only warn about unreachable range patterns when appropriate

Also simplifies the literal-munging, and moves it into ast_util

Closes #1170

5 files changed, 15 insertions, 35 deletions

diff --git a/src/comp/middle/check_alt.rs b/src/comp/middle/check_alt.rs
index b79ded04c27..380fcff24b6 100644
--- a/src/comp/middle/check_alt.rs
+++ b/src/comp/middle/check_alt.rs
@@ -1,5 +1,5 @@
 import syntax::ast::*;
-import syntax::ast_util::{variant_def_ids, dummy_sp};
+import syntax::ast_util::{variant_def_ids, dummy_sp, compare_lit, lit_eq};
 import syntax::visit;
 
 fn check_crate(tcx: ty::ctxt, crate: @crate) {
@@ -66,11 +66,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 util::common::lit_eq(la, lb); }
-          pat_range(beginb, endb) {
-            ret util::common::lit_type_eq(la, beginb) &&
-                util::common::lit_in_range(la, beginb, endb);
-          }
+          pat_lit(lb) { ret lit_eq(la, lb); }
           _ { ret false; }
         }
       }
@@ -110,12 +106,11 @@ fn pattern_supersedes(tcx: ty::ctxt, a: @pat, b: @pat) -> bool {
       pat_range(begina, enda) {
         alt b.node {
           pat_lit(lb) {
-            ret util::common::lit_type_eq(lb, begina) &&
-                util::common::lit_in_range(lb, begina, enda);
+            ret compare_lit(begina, lb) <= 0 && compare_lit(enda, lb) >= 0;
           }
           pat_range(beginb, endb) {
-            ret util::common::lit_type_eq(begina, beginb) &&
-                util::common::lit_ranges_overlap(begina, enda, beginb, endb);
+            ret compare_lit(begina, beginb) <= 0 &&
+                compare_lit(enda, endb) >= 0;
           }
           _ { ret false; }
         }
diff --git a/src/comp/middle/trans_alt.rs b/src/comp/middle/trans_alt.rs
index af0a1890f3e..5b7b7a59294 100644
--- a/src/comp/middle/trans_alt.rs
+++ b/src/comp/middle/trans_alt.rs
@@ -7,10 +7,9 @@ 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;
+import syntax::ast_util::{dummy_sp, lit_eq};
 import syntax::ast::def_id;
 import syntax::codemap::span;
-import util::common::lit_eq;
 
 import trans_common::*;
 
diff --git a/src/comp/middle/tstate/auxiliary.rs b/src/comp/middle/tstate/auxiliary.rs
index 6e35aabf032..e7c17665628 100644
--- a/src/comp/middle/tstate/auxiliary.rs
+++ b/src/comp/middle/tstate/auxiliary.rs
@@ -5,7 +5,6 @@ import syntax::ast_util::*;
 import syntax::codemap::span;
 import syntax::visit;
 import std::map::{new_int_hash};
-import util::common::{lit_eq};
 import syntax::print::pprust::path_to_str;
 import tstate::ann::{pre_and_post, pre_and_post_state, empty_ann, prestate,
                      poststate, precond, postcond,
diff --git a/src/comp/middle/ty.rs b/src/comp/middle/ty.rs
index 9471c4e01c5..e950633284f 100644
--- a/src/comp/middle/ty.rs
+++ b/src/comp/middle/ty.rs
@@ -1443,7 +1443,9 @@ fn arg_eq<T>(eq: fn(T, T) -> bool, a: @sp_constr_arg<T>, b: @sp_constr_arg<T>)
         alt b.node { ast::carg_ident(t) { ret eq(s, t); } _ { ret false; } }
       }
       ast::carg_lit(l) {
-        alt b.node { ast::carg_lit(m) { ret lit_eq(l, m); } _ { ret false; } }
+        alt b.node {
+          ast::carg_lit(m) { ret ast_util::lit_eq(l, m); } _ { ret false; }
+        }
       }
     }
 }
diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs
index 156c1cf1138..0858833af6d 100644
--- a/src/comp/middle/typeck.rs
+++ b/src/comp/middle/typeck.rs
@@ -1,6 +1,7 @@
 import syntax::{ast, ast_util};
 import ast::spanned;
-import syntax::ast_util::{local_def, respan, ty_param_kind};
+import syntax::ast_util::{local_def, respan, ty_param_kind, lit_is_numeric,
+                          lit_types_match};
 import syntax::visit;
 import metadata::csearch;
 import driver::session;
@@ -1252,24 +1253,7 @@ fn lit_as_float(l: @ast::lit) -> str {
 }
 
 fn valid_range_bounds(l1: @ast::lit, l2: @ast::lit) -> bool {
-    alt l1.node {
-      ast::lit_float(s1) | ast::lit_mach_float(_, s1) {
-        let s2 = lit_as_float(l2);
-        let f1 = std::float::from_str(s1);
-        let f2 = std::float::from_str(s2);
-        ret std::math::min(f1, f2) == f1
-      }
-      ast::lit_uint(_) | ast::lit_char(_) {
-        let u1 = lit_as_uint(l1);
-        let u2 = lit_as_uint(l2);
-        ret std::math::min(u1, u2) == u1
-      }
-      _ {
-        let i1 = lit_as_int(l1);
-        let i2 = lit_as_int(l2);
-        ret std::math::min(i1, i2) == i1
-      }
-    }
+    ast_util::compare_lit(l1, l2) <= 0
 }
 
 // Pattern checking is top-down rather than bottom-up so that bindings get
@@ -1284,8 +1268,9 @@ fn check_pat(fcx: @fn_ctxt, map: ast_util::pat_id_map, pat: @ast::pat,
         write::ty_only_fixup(fcx, pat.id, typ);
       }
       ast::pat_range(begin, end) {
-        if !util::common::lit_is_numeric(begin) ||
-           !util::common::lit_is_numeric(end) {
+        if !lit_types_match(begin, end) {
+            fcx.ccx.tcx.sess.span_err(pat.span, "mismatched types in range");
+        } else if !lit_is_numeric(begin) || !lit_is_numeric(end) {
             fcx.ccx.tcx.sess.span_err(pat.span,
                                       "non-numeric type used in range");
         } else if !valid_range_bounds(begin, end) {