rustc: Make shape-based compare glue never called for comparison operators.

Only called for string patterns.

7 files changed, 57 insertions, 36 deletions

diff --git a/src/rustc/middle/borrowck/check_loans.rs b/src/rustc/middle/borrowck/check_loans.rs
index c45e6d03546..2d4f988c007 100644
--- a/src/rustc/middle/borrowck/check_loans.rs
+++ b/src/rustc/middle/borrowck/check_loans.rs
@@ -79,6 +79,13 @@ enum assignment_type {
     at_mutbl_ref,
 }
 
+impl assignment_type : cmp::Eq {
+    pure fn eq(&&other: assignment_type) -> bool {
+        (self as uint) == (other as uint)
+    }
+    pure fn ne(&&other: assignment_type) -> bool { !self.eq(other) }
+}
+
 impl assignment_type {
     fn checked_by_liveness() -> bool {
         // the liveness pass guarantees that immutable local variables
diff --git a/src/rustc/middle/resolve.rs b/src/rustc/middle/resolve.rs
index 94786aa8a89..b85b10e50e8 100644
--- a/src/rustc/middle/resolve.rs
+++ b/src/rustc/middle/resolve.rs
@@ -210,6 +210,15 @@ enum ResolveResult<T> {
     Success(T)      // Successfully resolved the import.
 }
 
+impl<T> ResolveResult<T> {
+    fn failed() -> bool {
+        match self { Failed => true, _ => false }
+    }
+    fn indeterminate() -> bool {
+        match self { Indeterminate => true, _ => false }
+    }
+}
+
 enum TypeParameters/& {
     NoTypeParameters,               //< No type parameters.
     HasTypeParameters(&~[ty_param], //< Type parameters.
@@ -558,9 +567,14 @@ struct NameBindings {
 
     fn defined_in_namespace(namespace: Namespace) -> bool {
         match namespace {
-            ModuleNS    => return self.module_def != NoModuleDef,
-            TypeNS      => return self.type_def != None,
-            ValueNS     => return self.value_def != None
+            ModuleNS => {
+                match self.module_def {
+                    NoModuleDef => false,
+                    _ => true
+                }
+            }
+            TypeNS   => return self.type_def.is_some(),
+            ValueNS  => return self.value_def.is_some()
         }
     }
 
@@ -1788,7 +1802,7 @@ struct Resolver {
         // processing imports here. (See the loop in
         // resolve_imports_for_module.)
 
-        if resolution_result != Indeterminate {
+        if !resolution_result.indeterminate() {
             match *import_directive.subclass {
                 GlobImport => {
                     assert module_.glob_count >= 1u;
diff --git a/src/rustc/middle/trans/expr.rs b/src/rustc/middle/trans/expr.rs
index b1ee870dbb5..0fe4f3cd917 100644
--- a/src/rustc/middle/trans/expr.rs
+++ b/src/rustc/middle/trans/expr.rs
@@ -1117,12 +1117,21 @@ fn trans_eager_binop(bcx: block,
             AShr(bcx, lhs, rhs)
         } else { LShr(bcx, lhs, rhs) }
       }
+      ast::eq | ast::ne | ast::lt | ast::ge | ast::le | ast::gt => {
+        if ty::type_is_bot(rhs_t) {
+            C_bool(false)
+        } else {
+            if !ty::type_is_scalar(rhs_t) {
+                bcx.tcx().sess.span_bug(binop_expr.span,
+                                        ~"non-scalar comparison");
+            }
+            let cmpr = base::compare_scalar_types(bcx, lhs, rhs, rhs_t, op);
+            bcx = cmpr.bcx;
+            cmpr.val
+        }
+      }
       _ => {
-        let cmpr = base::trans_compare(bcx, op,
-                                       lhs, lhs_t,
-                                       rhs, rhs_t);
-        bcx = cmpr.bcx;
-        cmpr.val
+        bcx.tcx().sess.span_bug(binop_expr.span, ~"unexpected binop");
       }
     };
 
diff --git a/src/rustc/middle/trans/shape.rs b/src/rustc/middle/trans/shape.rs
index d65b0e1978c..cdbaf6e5ee2 100644
--- a/src/rustc/middle/trans/shape.rs
+++ b/src/rustc/middle/trans/shape.rs
@@ -516,12 +516,14 @@ fn gen_enum_shapes(ccx: @crate_ctxt) -> ValueRef {
                             ranges[i].align.bounded &&
                             ranges[j].size.bounded &&
                             ranges[j].align.bounded {
-                            if ranges[i].size >= ranges[j].size &&
-                                ranges[i].align >= ranges[j].align {
+                            if ranges[i].size.min >= ranges[j].size.min &&
+                                ranges[i].align.min >= ranges[j].align.min {
                                 // Throw out j.
                                 candidates[j] = false;
-                            } else if ranges[j].size >= ranges[i].size &&
-                                ranges[j].align >= ranges[j].align {
+                            } else if ranges[j].size.min >=
+                                    ranges[i].size.min &&
+                                ranges[j].align.min >=
+                                    ranges[j].align.min {
                                 // Throw out i.
                                 candidates[i] = false;
                             }
diff --git a/src/rustc/middle/ty.rs b/src/rustc/middle/ty.rs
index e6476b57e70..b8d610e7a15 100644
--- a/src/rustc/middle/ty.rs
+++ b/src/rustc/middle/ty.rs
@@ -3081,8 +3081,8 @@ fn occurs_check(tcx: ctxt, sp: span, vid: TyVid, rt: t) {
 
 // Maintains a little union-set tree for inferred modes.  `canon()` returns
 // the current head value for `m0`.
-fn canon<T:Copy>(tbl: hashmap<ast::node_id, ast::inferable<T>>,
-                 +m0: ast::inferable<T>) -> ast::inferable<T> {
+fn canon<T:Copy cmp::Eq>(tbl: hashmap<ast::node_id, ast::inferable<T>>,
+                         +m0: ast::inferable<T>) -> ast::inferable<T> {
     match m0 {
       ast::infer(id) => match tbl.find(id) {
         None => m0,
diff --git a/src/rustc/middle/typeck/check.rs b/src/rustc/middle/typeck/check.rs
index f63f6f2e125..677a7a444f0 100644
--- a/src/rustc/middle/typeck/check.rs
+++ b/src/rustc/middle/typeck/check.rs
@@ -1132,7 +1132,13 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
             let rhs_bot = check_expr_with(fcx, rhs, tvar);
             let result_t = match op {
               ast::eq | ast::lt | ast::le | ast::ne | ast::ge |
-              ast::gt => ty::mk_bool(fcx.ccx.tcx),
+              ast::gt => {
+                if !ty::type_is_scalar(lhs_t) {
+                    fcx.ccx.tcx.sess.span_bug(expr.span,
+                                              ~"non-scalar compare");
+                }
+                ty::mk_bool(fcx.ccx.tcx)
+              }
               _ => lhs_t
             };
             fcx.write_ty(expr.id, result_t);
@@ -1410,23 +1416,6 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
         let typ = check_lit(fcx, lit);
         fcx.write_ty(id, typ);
       }
-
-      // Something of a hack: special rules for comparison operators that
-      // simply unify LHS and RHS.  This helps with inference as LHS and RHS
-      // do not need to be "resolvable".  Some tests, particularly those with
-      // complicated trait requirements, fail without this---I think this code
-      // can be removed if we improve trait resolution to be more eager when
-      // possible.
-      ast::expr_binary(ast::ne, lhs, rhs) |
-      ast::expr_binary(ast::le, lhs, rhs) |
-      ast::expr_binary(ast::gt, lhs, rhs) |
-      ast::expr_binary(ast::ge, lhs, rhs) => {
-        let tcx = fcx.ccx.tcx;
-        let tvar = fcx.infcx().next_ty_var();
-        bot |= check_expr_with(fcx, lhs, tvar);
-        bot |= check_expr_with(fcx, rhs, tvar);
-        fcx.write_ty(id, ty::mk_bool(tcx));
-      }
       ast::expr_binary(op, lhs, rhs) => {
         bot |= check_binop(fcx, expr, op, lhs, rhs);
       }
@@ -1806,7 +1795,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
       }
       ast::expr_rec(fields, base) => {
         option::iter(base, |b| { check_expr(fcx, b, expected); });
-        let expected = if expected == None && base != None {
+        let expected = if expected.is_none() && base.is_some() {
             Some(fcx.expr_ty(base.get()))
         } else { expected };
         let flds = unpack_expected(fcx, expected, |sty|
diff --git a/src/rustc/middle/typeck/infer/unify.rs b/src/rustc/middle/typeck/infer/unify.rs
index 2793d0e4f5a..500a4d5b419 100644
--- a/src/rustc/middle/typeck/infer/unify.rs
+++ b/src/rustc/middle/typeck/infer/unify.rs
@@ -20,7 +20,7 @@ struct node<V:Copy, T:Copy> {
 }
 
 impl infer_ctxt {
-    fn get<V:Copy vid, T:Copy>(
+    fn get<V:Copy vid Eq, T:Copy>(
         vb: &vals_and_bindings<V, T>, vid: V) -> node<V, T> {
 
         let vid_u = vid.to_uint();
@@ -377,4 +377,4 @@ impl infer_ctxt {
     }
 
 
-}
\ No newline at end of file
+}