Specific labels when referring to "expected" and "found" types

Author: estebank

src/librustc/infer/error_reporting/mod.rs

@@ -1197,18 +1197,25 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         };
 
         if let Some((expected, found)) = expected_found {
+            let expected_label = exp_found.map(|ef| ef.expected.prefix_string())
+                .unwrap_or("type".into());
+            let found_label = exp_found.map(|ef| ef.found.prefix_string())
+                .unwrap_or("type".into());
             match (terr, is_simple_error, expected == found) {
-                (&TypeError::Sorts(ref values), false, true) => {
-                    let sort_string = | a_type: Ty<'tcx> |
-                        if let ty::Opaque(def_id, _) = a_type.kind {
-                            format!(" (opaque type at {})", self.tcx.sess.source_map()
-                                .mk_substr_filename(self.tcx.def_span(def_id)))
-                        } else {
-                            format!(" ({})", a_type.sort_string(self.tcx))
-                        };
+                (&TypeError::Sorts(ref values), false, extra) => {
+                    let sort_string = |ty: Ty<'tcx>| match (extra, &ty.kind) {
+                        (true, ty::Opaque(def_id, _)) => format!(
+                            " (opaque type at {})",
+                            self.tcx.sess.source_map()
+                                .mk_substr_filename(self.tcx.def_span(*def_id)),
+                        ),
+                        (true, _) => format!(" ({})", ty.sort_string(self.tcx)),
+                        (false, _) => "".to_string(),
+                    };
                     diag.note_expected_found_extra(
-                        &"type",
+                        &expected_label,
                         expected,
+                        &found_label,
                         found,
                         &sort_string(values.expected),
                         &sort_string(values.found),
@@ -1222,15 +1229,14 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
                         "note_type_err: exp_found={:?}, expected={:?} found={:?}",
                         exp_found, expected, found
                     );
-                    if let Some(exp_found) = exp_found {
-                        self.suggest_as_ref_where_appropriate(span, &exp_found, diag);
-                    }
-
-                    diag.note_expected_found(&"type", expected, found);
+                    diag.note_expected_found(&expected_label, expected, &found_label, found);
                 }
                 _ => (),
             }
         }
+        if let Some(exp_found) = exp_found {
+            self.suggest_as_ref_where_appropriate(span, &exp_found, diag);
+        }
 
         // In some (most?) cases cause.body_id points to actual body, but in some cases
         // it's a actual definition. According to the comments (e.g. in

src/librustc/ty/error.rs

@@ -246,6 +246,37 @@ impl<'tcx> ty::TyS<'tcx> {
             ty::Error => "type error".into(),
         }
     }
+
+    pub fn prefix_string(&self) -> Cow<'static, str> {
+        debug!("prefix_string {:?} {} {:?}", self, self, self.kind);
+        match self.kind {
+            ty::Infer(_) | ty::Error | ty::Bool | ty::Char | ty::Int(_) |
+            ty::Uint(_) | ty::Float(_) | ty::Str | ty::Never => "type".into(),
+            ty::Tuple(ref tys) if tys.is_empty() => "type".into(),
+            ty::Adt(def, _) => def.descr().into(),
+            ty::Foreign(_) => "extern type".into(),
+            ty::Array(..) => "array".into(),
+            ty::Slice(_) => "slice".into(),
+            ty::RawPtr(_) => "raw pointer".into(),
+            ty::Ref(.., mutbl) => match mutbl {
+                hir::Mutability::Mutable => "mutable reference",
+                _ => "reference"
+            }.into(),
+            ty::FnDef(..) => "fn item".into(),
+            ty::FnPtr(_) => "fn pointer".into(),
+            ty::Dynamic(..) => "trait".into(),
+            ty::Closure(..) => "closure".into(),
+            ty::Generator(..) => "generator".into(),
+            ty::GeneratorWitness(..) => "generator witness".into(),
+            ty::Tuple(..) => "tuple".into(),
+            ty::Placeholder(..) => "placeholder type".into(),
+            ty::Bound(..) => "bound type".into(),
+            ty::Projection(_) => "associated type".into(),
+            ty::UnnormalizedProjection(_) => "associated type".into(),
+            ty::Param(_) => "type parameter".into(),
+            ty::Opaque(..) => "opaque type".into(),
+        }
+    }
 }
 
 impl<'tcx> TyCtxt<'tcx> {

src/librustc_errors/diagnostic.rs

@@ -143,20 +143,21 @@ impl Diagnostic {
         self
     }
 
-    pub fn note_expected_found(&mut self,
-                               label: &dyn fmt::Display,
-                               expected: DiagnosticStyledString,
-                               found: DiagnosticStyledString)
-                               -> &mut Self
-    {
-        self.note_expected_found_extra(label, expected, found, &"", &"")
-    }
-
-    pub fn note_unsuccessfull_coercion(&mut self,
-                                       expected: DiagnosticStyledString,
-                                       found: DiagnosticStyledString)
-                                       -> &mut Self
-    {
+    pub fn note_expected_found(
+        &mut self,
+        expected_label: &dyn fmt::Display,
+        expected: DiagnosticStyledString,
+        found_label: &dyn fmt::Display,
+        found: DiagnosticStyledString,
+    ) -> &mut Self {
+        self.note_expected_found_extra(expected_label, expected, found_label, found, &"", &"")
+    }
+
+    pub fn note_unsuccessfull_coercion(
+        &mut self,
+        expected: DiagnosticStyledString,
+        found: DiagnosticStyledString,
+    ) -> &mut Self {
         let mut msg: Vec<_> =
             vec![(format!("required when trying to coerce from type `"),
                   Style::NoStyle)];
@@ -178,27 +179,38 @@ impl Diagnostic {
         self
     }
 
-    pub fn note_expected_found_extra(&mut self,
-                                     label: &dyn fmt::Display,
-                                     expected: DiagnosticStyledString,
-                                     found: DiagnosticStyledString,
-                                     expected_extra: &dyn fmt::Display,
-                                     found_extra: &dyn fmt::Display)
-                                     -> &mut Self
-    {
-        let mut msg: Vec<_> = vec![(format!("expected {} `", label), Style::NoStyle)];
+    pub fn note_expected_found_extra(
+        &mut self,
+        expected_label: &dyn fmt::Display,
+        expected: DiagnosticStyledString,
+        found_label: &dyn fmt::Display,
+        found: DiagnosticStyledString,
+        expected_extra: &dyn fmt::Display,
+        found_extra: &dyn fmt::Display,
+    ) -> &mut Self {
+        let expected_label = format!("expected {}", expected_label);
+        let found_label = format!("found {}", found_label);
+        let (found_padding, expected_padding) = if expected_label.len() > found_label.len() {
+            (expected_label.len() - found_label.len(), 0)
+        } else {
+            (0, found_label.len() - expected_label.len())
+        };
+        let mut msg: Vec<_> = vec![(
+            format!("{}{} `", " ".repeat(expected_padding), expected_label),
+            Style::NoStyle,
+        )];
         msg.extend(expected.0.iter()
-                   .map(|x| match *x {
-                       StringPart::Normal(ref s) => (s.to_owned(), Style::NoStyle),
-                       StringPart::Highlighted(ref s) => (s.to_owned(), Style::Highlight),
-                   }));
+            .map(|x| match *x {
+                StringPart::Normal(ref s) => (s.to_owned(), Style::NoStyle),
+                StringPart::Highlighted(ref s) => (s.to_owned(), Style::Highlight),
+            }));
         msg.push((format!("`{}\n", expected_extra), Style::NoStyle));
-        msg.push((format!("   found {} `", label), Style::NoStyle));
+        msg.push((format!("{}{} `", " ".repeat(found_padding), found_label), Style::NoStyle));
         msg.extend(found.0.iter()
-                   .map(|x| match *x {
-                       StringPart::Normal(ref s) => (s.to_owned(), Style::NoStyle),
-                       StringPart::Highlighted(ref s) => (s.to_owned(), Style::Highlight),
-                   }));
+            .map(|x| match *x {
+                StringPart::Normal(ref s) => (s.to_owned(), Style::NoStyle),
+                StringPart::Highlighted(ref s) => (s.to_owned(), Style::Highlight),
+            }));
         msg.push((format!("`{}", found_extra), Style::NoStyle));
 
         // For now, just attach these as notes

src/librustc_errors/diagnostic_builder.rs

@@ -195,37 +195,44 @@ impl<'a> DiagnosticBuilder<'a> {
         self
     }
 
-    forward!(pub fn note_expected_found(&mut self,
-                                        label: &dyn fmt::Display,
-                                        expected: DiagnosticStyledString,
-                                        found: DiagnosticStyledString,
-                                        ) -> &mut Self);
-
-    forward!(pub fn note_expected_found_extra(&mut self,
-                                              label: &dyn fmt::Display,
-                                              expected: DiagnosticStyledString,
-                                              found: DiagnosticStyledString,
-                                              expected_extra: &dyn fmt::Display,
-                                              found_extra: &dyn fmt::Display,
-                                              ) -> &mut Self);
-
-    forward!(pub fn note_unsuccessfull_coercion(&mut self,
-                                                expected: DiagnosticStyledString,
-                                                found: DiagnosticStyledString,
-                                                ) -> &mut Self);
+    forward!(pub fn note_expected_found(
+        &mut self,
+        expected_label: &dyn fmt::Display,
+        expected: DiagnosticStyledString,
+        found_label: &dyn fmt::Display,
+        found: DiagnosticStyledString,
+    ) -> &mut Self);
+
+    forward!(pub fn note_expected_found_extra(
+        &mut self,
+        expected_label: &dyn fmt::Display,
+        expected: DiagnosticStyledString,
+        found_label: &dyn fmt::Display,
+        found: DiagnosticStyledString,
+        expected_extra: &dyn fmt::Display,
+        found_extra: &dyn fmt::Display,
+    ) -> &mut Self);
+
+    forward!(pub fn note_unsuccessfull_coercion(
+        &mut self,
+        expected: DiagnosticStyledString,
+        found: DiagnosticStyledString,
+    ) -> &mut Self);
 
     forward!(pub fn note(&mut self, msg: &str) -> &mut Self);
-    forward!(pub fn span_note<S: Into<MultiSpan>>(&mut self,
-                                                  sp: S,
-                                                  msg: &str,
-                                                  ) -> &mut Self);
+    forward!(pub fn span_note<S: Into<MultiSpan>>(
+        &mut self,
+        sp: S,
+        msg: &str,
+    ) -> &mut Self);
     forward!(pub fn warn(&mut self, msg: &str) -> &mut Self);
     forward!(pub fn span_warn<S: Into<MultiSpan>>(&mut self, sp: S, msg: &str) -> &mut Self);
     forward!(pub fn help(&mut self, msg: &str) -> &mut Self);
-    forward!(pub fn span_help<S: Into<MultiSpan>>(&mut self,
-                                                  sp: S,
-                                                  msg: &str,
-                                                  ) -> &mut Self);
+    forward!(pub fn span_help<S: Into<MultiSpan>>(
+        &mut self,
+        sp: S,
+        msg: &str,
+    ) -> &mut Self);
 
     pub fn multipart_suggestion(
         &mut self,

src/test/ui/array-break-length.stderr

@@ -17,7 +17,7 @@ LL |         |_: [_; break]| {}
    |         ^^^^^^^^^^^^^^^^^^ expected (), found closure
    |
    = note: expected type `()`
-              found type `[closure@$DIR/array-break-length.rs:3:9: 3:27]`
+           found closure `[closure@$DIR/array-break-length.rs:3:9: 3:27]`
 
 error[E0308]: mismatched types
   --> $DIR/array-break-length.rs:8:9
@@ -26,7 +26,7 @@ LL |         |_: [_; continue]| {}
    |         ^^^^^^^^^^^^^^^^^^^^^ expected (), found closure
    |
    = note: expected type `()`
-              found type `[closure@$DIR/array-break-length.rs:8:9: 8:30]`
+           found closure `[closure@$DIR/array-break-length.rs:8:9: 8:30]`
 
 error: aborting due to 4 previous errors
 

src/test/ui/array-not-vector.rs

@@ -2,13 +2,13 @@ fn main() {
     let _x: i32 = [1, 2, 3];
     //~^ ERROR mismatched types
     //~| expected type `i32`
-    //~| found type `[{integer}; 3]`
+    //~| found array `[{integer}; 3]`
     //~| expected i32, found array of 3 elements
 
     let x: &[i32] = &[1, 2, 3];
     let _y: &i32 = x;
     //~^ ERROR mismatched types
-    //~| expected type `&i32`
-    //~| found type `&[i32]`
+    //~| expected reference `&i32`
+    //~| found reference `&[i32]`
     //~| expected i32, found slice
 }

src/test/ui/array-not-vector.stderr

@@ -5,16 +5,16 @@ LL |     let _x: i32 = [1, 2, 3];
    |                   ^^^^^^^^^ expected i32, found array of 3 elements
    |
    = note: expected type `i32`
-              found type `[{integer}; 3]`
+             found array `[{integer}; 3]`
 
 error[E0308]: mismatched types
   --> $DIR/array-not-vector.rs:9:20
    |
 LL |     let _y: &i32 = x;
    |                    ^ expected i32, found slice
    |
-   = note: expected type `&i32`
-              found type `&[i32]`
+   = note: expected reference `&i32`
+              found reference `&[i32]`
 
 error: aborting due to 2 previous errors
 

src/test/ui/associated-const/associated-const-generic-obligations.stderr

@@ -7,8 +7,8 @@ LL |     const FROM: Self::Out;
 LL |     const FROM: &'static str = "foo";
    |                 ^^^^^^^^^^^^ expected associated type, found reference
    |
-   = note: expected type `<T as Foo>::Out`
-              found type `&'static str`
+   = note: expected associated type `<T as Foo>::Out`
+                    found reference `&'static str`
    = note: consider constraining the associated type `<T as Foo>::Out` to `&'static str` or calling a method that returns `<T as Foo>::Out`
    = note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
 

src/test/ui/associated-const/associated-const-impl-wrong-lifetime.stderr

@@ -4,8 +4,8 @@ error[E0308]: mismatched types
 LL |     const NAME: &'a str = "unit";
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ lifetime mismatch
    |
-   = note: expected type `&'static str`
-              found type `&'a str`
+   = note: expected reference `&'static str`
+              found reference `&'a str`
 note: the lifetime `'a` as defined on the impl at 6:6...
   --> $DIR/associated-const-impl-wrong-lifetime.rs:6:6
    |

src/test/ui/associated-type/associated-type-projection-from-supertrait.stderr

@@ -4,35 +4,35 @@ error[E0308]: mismatched types
 LL | fn b() { dent(ModelT, Blue); }
    |                       ^^^^ expected struct `Black`, found struct `Blue`
    |
-   = note: expected type `Black`
-              found type `Blue`
+   = note: expected struct `Black`
+              found struct `Blue`
 
 error[E0308]: mismatched types
   --> $DIR/associated-type-projection-from-supertrait.rs:28:23
    |
 LL | fn c() { dent(ModelU, Black); }
    |                       ^^^^^ expected struct `Blue`, found struct `Black`
    |
-   = note: expected type `Blue`
-              found type `Black`
+   = note: expected struct `Blue`
+              found struct `Black`
 
 error[E0308]: mismatched types
   --> $DIR/associated-type-projection-from-supertrait.rs:32:28
    |
 LL | fn f() { ModelT.chip_paint(Blue); }
    |                            ^^^^ expected struct `Black`, found struct `Blue`
    |
-   = note: expected type `Black`
-              found type `Blue`
+   = note: expected struct `Black`
+              found struct `Blue`
 
 error[E0308]: mismatched types
   --> $DIR/associated-type-projection-from-supertrait.rs:33:28
    |
 LL | fn g() { ModelU.chip_paint(Black); }
    |                            ^^^^^ expected struct `Blue`, found struct `Black`
    |
-   = note: expected type `Blue`
-              found type `Black`
+   = note: expected struct `Blue`
+              found struct `Black`
 
 error: aborting due to 4 previous errors