Fix reversed current/expected type

It is reversed that type of arm pattern and type of search pattern
in error message.

Author: youknowone

src/librustc/middle/typeck/check/_match.rs

@@ -103,7 +103,7 @@ pub fn check_pat_variant(pcx: pat_ctxt, pat: @ast::pat, path: @ast::path,
             // check that the type of the value being matched is a subtype
             // of the type of the pattern:
             let pat_ty = fcx.node_ty(pat.id);
-            demand::suptype(fcx, pat.span, pat_ty, expected);
+            demand::subtype(fcx, pat.span, expected, pat_ty);
 
             // Get the expected types of the arguments.
             arg_types = {
@@ -142,7 +142,7 @@ pub fn check_pat_variant(pcx: pat_ctxt, pat: @ast::pat, path: @ast::path,
             // Check that the type of the value being matched is a subtype of
             // the type of the pattern.
             let pat_ty = fcx.node_ty(pat.id);
-            demand::suptype(fcx, pat.span, pat_ty, expected);
+            demand::subtype(fcx, pat.span, expected, pat_ty);
 
             // Get the expected types of the arguments.
             let class_fields = ty::struct_fields(
@@ -153,7 +153,7 @@ pub fn check_pat_variant(pcx: pat_ctxt, pat: @ast::pat, path: @ast::path,
         }
         _ => {
             tcx.sess.span_fatal(
-                pat.span,
+                pat.span, // XXX: should be discrim.span or other error
                 fmt!("mismatched types: expected enum or structure but \
                       found `%s`",
                      fcx.infcx().ty_to_str(expected)));

src/librustc/middle/typeck/check/demand.rs

@@ -21,20 +21,25 @@ use syntax::codemap::span;
 // Requires that the two types unify, and prints an error message if they
 // don't.
 pub fn suptype(fcx: @mut FnCtxt, sp: span, expected: ty::t, actual: ty::t) {
-    suptype_with_fn(fcx, sp, expected, actual,
+    suptype_with_fn(fcx, sp, false, expected, actual,
         |sp, e, a, s| { fcx.report_mismatched_types(sp, e, a, s) })
 }
 
+pub fn subtype(fcx: @mut FnCtxt, sp: span, expected: ty::t, actual: ty::t) {
+    suptype_with_fn(fcx, sp, true, actual, expected,
+        |sp, a, e, s| { fcx.report_mismatched_types(sp, e, a, s) })
+}
+
 pub fn suptype_with_fn(fcx: @mut FnCtxt,
-                       sp: span,
-                       expected: ty::t, actual: ty::t,
+                       sp: span, a_is_actual: bool,
+                       ty_a: ty::t, ty_b: ty::t,
                        handle_err: fn(span, ty::t, ty::t, &ty::type_err)) {
     // n.b.: order of actual, expected is reversed
-    match infer::mk_subty(fcx.infcx(), false, sp,
-                          actual, expected) {
+    match infer::mk_subty(fcx.infcx(), a_is_actual, sp,
+                          ty_b, ty_a) {
       result::Ok(()) => { /* ok */ }
       result::Err(ref err) => {
-          handle_err(sp, expected, actual, err);
+          handle_err(sp, ty_a, ty_b, err);
       }
     }
 }

src/librustc/middle/typeck/check/mod.rs

@@ -355,7 +355,8 @@ pub fn check_fn(ccx: @mut CrateCtxt,
         let tail_expr_ty = fcx.expr_ty(tail_expr);
         // Special case: we print a special error if there appears
         // to be do-block/for-loop confusion
-        demand::suptype_with_fn(fcx, tail_expr.span, fcx.ret_ty, tail_expr_ty,
+        demand::suptype_with_fn(fcx, tail_expr.span, false,
+            fcx.ret_ty, tail_expr_ty,
             |sp, e, a, s| {
                 fcx.report_mismatched_return_types(sp, e, a, s) });
       }

src/test/compile-fail/match-struct.rs

@@ -1,11 +1,10 @@
-// error-pattern: mismatched types
 
 struct S { a: int }
 enum E { C(int) }
 
 fn main() {
     match S { a: 1 } {
-        C(_) => (),
+        C(_) => (), //~ ERROR mismatched types: expected `S` but found `E`
         _ => ()
     }
 }