Change the way type variables are printed in diagnostics

src/librustc/middle/ty.rs

@@ -1032,10 +1032,8 @@ pub enum type_err {
     terr_ref_mutability,
     terr_vec_mutability,
     terr_tuple_size(expected_found<uint>),
+    terr_fixed_array_size(expected_found<uint>),
     terr_ty_param_size(expected_found<uint>),
-    terr_record_size(expected_found<uint>),
-    terr_record_mutability,
-    terr_record_fields(expected_found<Ident>),
     terr_arg_count,
     terr_regions_does_not_outlive(Region, Region),
     terr_regions_not_same(Region, Region),
@@ -3790,8 +3788,8 @@ pub fn ty_sort_string(cx: &ctxt, t: t) -> String {
 
         ty_enum(id, _) => format!("enum {}", item_path_str(cx, id)),
         ty_uniq(_) => "box".to_string(),
-        ty_vec(_, Some(_)) => "array".to_string(),
-        ty_vec(_, None) => "unsized array".to_string(),
+        ty_vec(_, Some(n)) => format!("array of {} elements", n),
+        ty_vec(_, None) => "slice".to_string(),
         ty_ptr(_) => "*-ptr".to_string(),
         ty_rptr(_, _) => "&-ptr".to_string(),
         ty_bare_fn(_) => "extern fn".to_string(),
@@ -3874,27 +3872,18 @@ pub fn type_err_to_str(cx: &ctxt, err: &type_err) -> String {
                     values.expected,
                     values.found)
         }
-        terr_tuple_size(values) => {
-            format!("expected a tuple with {} elements, \
+        terr_fixed_array_size(values) => {
+            format!("expected an array with a fixed size of {} elements, \
                      found one with {} elements",
                     values.expected,
                     values.found)
         }
-        terr_record_size(values) => {
-            format!("expected a record with {} fields, \
-                     found one with {} fields",
+        terr_tuple_size(values) => {
+            format!("expected a tuple with {} elements, \
+                     found one with {} elements",
                     values.expected,
                     values.found)
         }
-        terr_record_mutability => {
-            "record elements differ in mutability".to_string()
-        }
-        terr_record_fields(values) => {
-            format!("expected a record with field `{}`, found one \
-                     with field `{}`",
-                    token::get_ident(values.expected),
-                    token::get_ident(values.found))
-        }
         terr_arg_count => {
             "incorrect number of function parameters".to_string()
         }
@@ -3923,9 +3912,15 @@ pub fn type_err_to_str(cx: &ctxt, err: &type_err) -> String {
                     trait_store_to_string(cx, (*values).found))
         }
         terr_sorts(values) => {
-            format!("expected {}, found {}",
-                    ty_sort_string(cx, values.expected),
-                    ty_sort_string(cx, values.found))
+            // A naive approach to making sure that we're not reporting silly errors such as:
+            // (expected closure, found closure).
+            let expected_str = ty_sort_string(cx, values.expected);
+            let found_str = ty_sort_string(cx, values.found);
+            if expected_str == found_str {
+                format!("expected {}, found a different {}", expected_str, found_str)
+            } else {
+                format!("expected {}, found {}", expected_str, found_str)
+            }
         }
         terr_traits(values) => {
             format!("expected trait `{}`, found trait `{}`",

src/librustc/middle/typeck/infer/combine.rs

@@ -515,6 +515,16 @@ pub fn super_tys<'tcx, C: Combine<'tcx>>(this: &C, a: ty::t, b: ty::t) -> cres<t
             Ok(ty::mk_rptr(tcx, r, mt))
       }
 
+      (&ty::ty_vec(a_t, Some(sz_a)), &ty::ty_vec(b_t, Some(sz_b))) => {
+        this.tys(a_t, b_t).and_then(|t| {
+            if sz_a == sz_b {
+                Ok(ty::mk_vec(tcx, t, Some(sz_a)))
+            } else {
+                Err(ty::terr_fixed_array_size(expected_found(this, sz_a, sz_b)))
+            }
+        })
+      }
+
       (&ty::ty_vec(a_t, sz_a), &ty::ty_vec(b_t, sz_b)) => {
         this.tys(a_t, b_t).and_then(|t| {
             if sz_a == sz_b {

src/librustc/middle/typeck/infer/error_reporting.rs

@@ -111,7 +111,7 @@ pub trait ErrorReporting {
 
     fn values_str(&self, values: &ValuePairs) -> Option<String>;
 
-    fn expected_found_str<T:UserString+Resolvable>(
+    fn expected_found_str<T: UserString + Resolvable>(
         &self,
         exp_found: &ty::expected_found<T>)
         -> Option<String>;
@@ -396,16 +396,12 @@ impl<'a, 'tcx> ErrorReporting for InferCtxt<'a, 'tcx> {
          * or None if this is a derived error.
          */
         match *values {
-            infer::Types(ref exp_found) => {
-                self.expected_found_str(exp_found)
-            }
-            infer::TraitRefs(ref exp_found) => {
-                self.expected_found_str(exp_found)
-            }
+            infer::Types(ref exp_found) => self.expected_found_str(exp_found),
+            infer::TraitRefs(ref exp_found) => self.expected_found_str(exp_found)
         }
     }
 
-    fn expected_found_str<T:UserString+Resolvable>(
+    fn expected_found_str<T: UserString + Resolvable>(
         &self,
         exp_found: &ty::expected_found<T>)
         -> Option<String>

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

@@ -36,7 +36,8 @@ use syntax::ast;
 use syntax::codemap;
 use syntax::codemap::Span;
 use util::common::indent;
-use util::ppaux::{bound_region_to_string, ty_to_string, trait_ref_to_string, Repr};
+use util::ppaux::{bound_region_to_string, ty_to_string};
+use util::ppaux::{trait_ref_to_string, Repr};
 
 use self::coercion::Coerce;
 use self::combine::{Combine, CombineFields};
@@ -900,32 +901,25 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
                                                 err: Option<&ty::type_err>) {
         debug!("hi! expected_ty = {}, actual_ty = {}", expected_ty, actual_ty);
 
-        let error_str = err.map_or("".to_string(), |t_err| {
-            format!(" ({})", ty::type_err_to_str(self.tcx, t_err))
-        });
         let resolved_expected = expected_ty.map(|e_ty| {
             self.resolve_type_vars_if_possible(e_ty)
         });
-        if !resolved_expected.map_or(false, |e| { ty::type_is_error(e) }) {
-            match resolved_expected {
-                None => {
-                    self.tcx
-                        .sess
-                        .span_err(sp,
-                                  format!("{}{}",
-                                          mk_msg(None, actual_ty),
-                                          error_str).as_slice())
-                }
-                Some(e) => {
-                    self.tcx.sess.span_err(sp,
-                        format!("{}{}",
-                                mk_msg(Some(self.ty_to_string(e)), actual_ty),
-                                error_str).as_slice());
+
+        match resolved_expected {
+            Some(t) if ty::type_is_error(t) => (),
+            _ => {
+                let error_str = err.map_or("".to_string(), |t_err| {
+                    format!(" ({})", ty::type_err_to_str(self.tcx, t_err))
+                });
+
+                self.tcx.sess.span_err(sp, format!("{}{}",
+                    mk_msg(resolved_expected.map(|t| self.ty_to_string(t)), actual_ty),
+                    error_str).as_slice());
+
+                for err in err.iter() {
+                    ty::note_and_explain_type_err(self.tcx, *err)
                 }
             }
-            for err in err.iter() {
-                ty::note_and_explain_type_err(self.tcx, *err)
-            }
         }
     }
 
@@ -945,25 +939,18 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
     }
 
     pub fn report_mismatched_types(&self,
-                                   sp: Span,
-                                   e: ty::t,
-                                   a: ty::t,
+                                   span: Span,
+                                   expected: ty::t,
+                                   actual: ty::t,
                                    err: &ty::type_err) {
-        let resolved_expected =
-            self.resolve_type_vars_if_possible(e);
-        let mk_msg = match ty::get(resolved_expected).sty {
-            // Don't report an error if expected is ty_err
-            ty::ty_err => return,
-            _ => {
-                // if I leave out : String, it infers &str and complains
-                |actual: String| {
-                    format!("mismatched types: expected `{}`, found `{}`",
-                            self.ty_to_string(resolved_expected),
-                            actual)
-                }
-            }
+        let trace = TypeTrace {
+            origin: Misc(span),
+            values: Types(ty::expected_found {
+                expected: expected,
+                found: actual
+            })
         };
-        self.type_error_message(sp, mk_msg, a, Some(err));
+        self.report_and_explain_type_error(trace, err);
     }
 
     pub fn replace_late_bound_regions_with_fresh_regions(&self,