wording fixes in error messages

Jonathan Turner · Jonathan Turner · commit 54d0acd2fc64 · 2016-08-19T16:05:37.000-07:00
diff --git a/src/librustc/ty/error.rs b/src/librustc/ty/error.rs
@@ -98,9 +98,9 @@ impl<'tcx> fmt::Display for TypeError<'tcx> {
                        values.expected,
                        values.found)
             }
-            Mutability => write!(f, "values differ in mutability"),
+            Mutability => write!(f, "types differ in mutability"),
             BoxMutability => {
-                write!(f, "boxed values differ in mutability")
+                write!(f, "boxed types differ in mutability")
             }
             VecMutability => write!(f, "vectors differ in mutability"),
             PtrMutability => write!(f, "pointers differ in mutability"),
diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs
@@ -426,7 +426,9 @@ impl EmitterWriter {
                             continue;
                         }
                         // Check to make sure we're not in any <*macros>
-                        if !cm.span_to_filename(def_site).contains("macros>") {
+                        if !cm.span_to_filename(def_site).contains("macros>") &&
+                            !trace.macro_decl_name.starts_with("#[")
+                        {
                             new_labels.push((trace.call_site,
                                              "in this macro invocation".to_string()));
                             break;
diff --git a/src/librustc_typeck/check/callee.rs b/src/librustc_typeck/check/callee.rs
@@ -29,7 +29,7 @@ use rustc::hir;
 pub fn check_legal_trait_for_method_call(ccx: &CrateCtxt, span: Span, trait_id: DefId) {
     if ccx.tcx.lang_items.drop_trait() == Some(trait_id) {
         struct_span_err!(ccx.tcx.sess, span, E0040, "explicit use of destructor method")
-            .span_label(span, &format!("call to destructor method"))
+            .span_label(span, &format!("explicit destructor calls not allowed"))
             .emit();
     }
 }
diff --git a/src/librustc_typeck/check/compare_method.rs b/src/librustc_typeck/check/compare_method.rs
@@ -402,7 +402,7 @@ pub fn compare_impl_method<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
             infcx.note_type_err(
                 &mut diag,
                 origin,
-                trait_err_span.map(|sp| (sp, format!("original trait requirement"))),
+                trait_err_span.map(|sp| (sp, format!("type in trait"))),
                 Some(infer::ValuePairs::Types(ExpectedFound {
                      expected: trait_fty,
                      found: impl_fty
@@ -575,7 +575,7 @@ pub fn compare_const_impl<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
             infcx.note_type_err(
                 &mut diag,
                 origin,
-                Some((trait_c_span, format!("original trait requirement"))),
+                Some((trait_c_span, format!("type in trait"))),
                 Some(infer::ValuePairs::Types(ExpectedFound {
                     expected: trait_ty,
                     found: impl_ty
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
@@ -1013,7 +1013,7 @@ fn check_impl_items_against_trait<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
                          // We can only get the spans from local trait definition
                          // Same for E0324 and E0325
                          if let Some(trait_span) = tcx.map.span_if_local(ty_trait_item.def_id()) {
-                            err.span_label(trait_span, &format!("original trait requirement"));
+                            err.span_label(trait_span, &format!("item in trait"));
                          }
                          err.emit()
                     }
@@ -1041,7 +1041,7 @@ fn check_impl_items_against_trait<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
                                   impl_trait_ref);
                          err.span_label(impl_item.span, &format!("does not match trait"));
                          if let Some(trait_span) = tcx.map.span_if_local(ty_trait_item.def_id()) {
-                            err.span_label(trait_span, &format!("original trait requirement"));
+                            err.span_label(trait_span, &format!("item in trait"));
                          }
                          err.emit()
                     }
@@ -1064,7 +1064,7 @@ fn check_impl_items_against_trait<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
                                   impl_trait_ref);
                          err.span_label(impl_item.span, &format!("does not match trait"));
                          if let Some(trait_span) = tcx.map.span_if_local(ty_trait_item.def_id()) {
-                            err.span_label(trait_span, &format!("original trait requirement"));
+                            err.span_label(trait_span, &format!("item in trait"));
                          }
                          err.emit()
                     }
@@ -4408,8 +4408,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                               expected at most {}, found {}",
                              count(type_defs.len()),
                              count(types.len()))
-                .span_label(span, &format!("expected {}",
-                            count(type_defs.len()))).emit();
+                .span_label(span, &format!("too many type parameters")).emit();
 
             // To prevent derived errors to accumulate due to extra
             // type parameters, we force instantiate_value_path to
diff --git a/src/librustc_typeck/coherence/orphan.rs b/src/librustc_typeck/coherence/orphan.rs
@@ -37,7 +37,7 @@ impl<'cx, 'tcx> OrphanChecker<'cx, 'tcx> {
                       "cannot define inherent `impl` for a type outside of the \
                        crate where the type is defined")
                 .span_label(item.span, &format!("impl for type defined outside of crate."))
-                .span_note(item.span, &format!("define and implement a trait or new type instead"))
+                .note("define and implement a trait or new type instead")
                 .emit();
         }
     }
diff --git a/src/librustc_typeck/diagnostics.rs b/src/librustc_typeck/diagnostics.rs
@@ -572,7 +572,7 @@ impl Foo for Bar {
     // error, expected u16, found i16
     fn foo(x: i16) { }
 
-    // error, values differ in mutability
+    // error, types differ in mutability
     fn bar(&mut self) { }
 }
 ```
diff --git a/src/test/compile-fail/E0040.rs b/src/test/compile-fail/E0040.rs
@@ -22,5 +22,5 @@ fn main() {
     let mut x = Foo { x: -7 };
     x.drop();
     //~^ ERROR E0040
-    //~| NOTE call to destructor method
+    //~| NOTE explicit destructor calls not allowed
 }
diff --git a/src/test/compile-fail/E0053.rs b/src/test/compile-fail/E0053.rs
@@ -9,8 +9,8 @@
 // except according to those terms.
 
 trait Foo {
-    fn foo(x: u16); //~ NOTE original trait requirement
-    fn bar(&self); //~ NOTE original trait requirement
+    fn foo(x: u16); //~ NOTE type in trait
+    fn bar(&self); //~ NOTE type in trait
 }
 
 struct Bar;
@@ -21,7 +21,7 @@ impl Foo for Bar {
     //~| NOTE expected u16
     fn bar(&mut self) { }
     //~^ ERROR method `bar` has an incompatible type for trait
-    //~| NOTE values differ in mutability
+    //~| NOTE types differ in mutability
     //~| NOTE expected type `fn(&Bar)`
     //~| NOTE found type `fn(&mut Bar)`
 }
diff --git a/src/test/compile-fail/E0087.rs b/src/test/compile-fail/E0087.rs
@@ -12,5 +12,5 @@ fn foo<T>() {}
 
 fn main() {
     foo::<f64, bool>(); //~ ERROR E0087
-    //~^ NOTE expected
+    //~^ NOTE too many type parameters
 }
diff --git a/src/test/compile-fail/associated-const-impl-wrong-type.rs b/src/test/compile-fail/associated-const-impl-wrong-type.rs
@@ -11,7 +11,7 @@
 #![feature(associated_consts)]
 
 trait Foo {
-    const BAR: u32; //~ NOTE original trait requirement
+    const BAR: u32; //~ NOTE type in trait
 }
 
 struct SignedBar;
diff --git a/src/test/compile-fail/coerce-mut.rs b/src/test/compile-fail/coerce-mut.rs
@@ -16,5 +16,5 @@ fn main() {
     //~^ ERROR mismatched types
     //~| expected type `&mut i32`
     //~| found type `&{integer}`
-    //~| values differ in mutability
+    //~| types differ in mutability
 }
diff --git a/src/test/compile-fail/fn-variance-1.rs b/src/test/compile-fail/fn-variance-1.rs
@@ -19,9 +19,9 @@ fn apply<T, F>(t: T, f: F) where F: FnOnce(T) {
 fn main() {
     apply(&3, takes_imm);
     apply(&3, takes_mut);
-    //~^ ERROR (values differ in mutability)
+    //~^ ERROR (types differ in mutability)
 
     apply(&mut 3, takes_mut);
     apply(&mut 3, takes_imm);
-    //~^ ERROR (values differ in mutability)
+    //~^ ERROR (types differ in mutability)
 }
diff --git a/src/test/compile-fail/impl-wrong-item-for-trait.rs b/src/test/compile-fail/impl-wrong-item-for-trait.rs
@@ -12,9 +12,9 @@
 
 trait Foo {
     fn bar(&self);
-    //~^ NOTE original trait requirement
-    //~| NOTE original trait requirement
-    const MY_CONST: u32; //~ NOTE original trait requirement
+    //~^ NOTE item in trait
+    //~| NOTE item in trait
+    const MY_CONST: u32; //~ NOTE item in trait
 }
 
 pub struct FooConstForMethod;
diff --git a/src/test/compile-fail/mut-pattern-mismatched.rs b/src/test/compile-fail/mut-pattern-mismatched.rs
@@ -16,7 +16,7 @@ fn main() {
      let &_ //~  ERROR mismatched types
             //~| expected type `&mut {integer}`
             //~| found type `&_`
-            //~| values differ in mutability
+            //~| types differ in mutability
         = foo;
     let &mut _ = foo;
 
@@ -25,6 +25,6 @@ fn main() {
     let &mut _ //~  ERROR mismatched types
                //~| expected type `&{integer}`
                //~| found type `&mut _`
-               //~| values differ in mutability
+               //~| types differ in mutability
          = bar;
 }
diff --git a/src/test/compile-fail/ptr-coercion.rs b/src/test/compile-fail/ptr-coercion.rs
@@ -17,17 +17,17 @@ pub fn main() {
     let x: *mut isize = x; //~  ERROR mismatched types
                            //~| expected type `*mut isize`
                            //~| found type `*const isize`
-                           //~| values differ in mutability
+                           //~| types differ in mutability
 
     // & -> *mut
     let x: *mut isize = &42; //~  ERROR mismatched types
                              //~| expected type `*mut isize`
                              //~| found type `&isize`
-                             //~| values differ in mutability
+                             //~| types differ in mutability
 
     let x: *const isize = &42;
     let x: *mut isize = x; //~  ERROR mismatched types
                            //~| expected type `*mut isize`
                            //~| found type `*const isize`
-                           //~| values differ in mutability
+                           //~| types differ in mutability
 }
diff --git a/src/test/compile-fail/slice-mut.rs b/src/test/compile-fail/slice-mut.rs
@@ -18,5 +18,5 @@ fn main() {
     //~^ ERROR mismatched types
     //~| expected type `&mut [_]`
     //~| found type `&[isize]`
-    //~| values differ in mutability
+    //~| types differ in mutability
 }
diff --git a/src/test/ui/mismatched_types/trait-impl-fn-incompatibility.stderr b/src/test/ui/mismatched_types/trait-impl-fn-incompatibility.stderr
@@ -2,7 +2,7 @@ error[E0053]: method `foo` has an incompatible type for trait
   --> $DIR/trait-impl-fn-incompatibility.rs:21:15
    |
 14 |     fn foo(x: u16);
-   |               --- original trait requirement
+   |               --- type in trait
 ...
 21 |     fn foo(x: i16) { }
    |               ^^^ expected u16, found i16
@@ -11,10 +11,10 @@ error[E0053]: method `bar` has an incompatible type for trait
   --> $DIR/trait-impl-fn-incompatibility.rs:22:28
    |
 15 |     fn bar(&mut self, bar: &mut Bar);
-   |                            -------- original trait requirement
+   |                            -------- type in trait
 ...
 22 |     fn bar(&mut self, bar: &Bar) { }
-   |                            ^^^^ values differ in mutability
+   |                            ^^^^ types differ in mutability
    |
    = note: expected type `fn(&mut Bar, &mut Bar)`
    = note:    found type `fn(&mut Bar, &Bar)`

Original file line number	Diff line number	Diff line change
`@@ -98,9 +98,9 @@ impl<'tcx> fmt::Display for TypeError<'tcx> {`
`98`	`98`	`values.expected,`
`99`	`99`	`values.found)`
`100`	`100`	`}`
`101`		`- Mutability => write!(f, "values differ in mutability"),`
	`101`	`+ Mutability => write!(f, "types differ in mutability"),`
`102`	`102`	`BoxMutability => {`
`103`		`- write!(f, "boxed values differ in mutability")`
	`103`	`+ write!(f, "boxed types differ in mutability")`
`104`	`104`	`}`
`105`	`105`	`VecMutability => write!(f, "vectors differ in mutability"),`
`106`	`106`	`PtrMutability => write!(f, "pointers differ in mutability"),`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ use rustc::hir;`
`29`	`29`	`pub fn check_legal_trait_for_method_call(ccx: &CrateCtxt, span: Span, trait_id: DefId) {`
`30`	`30`	`if ccx.tcx.lang_items.drop_trait() == Some(trait_id) {`
`31`	`31`	`struct_span_err!(ccx.tcx.sess, span, E0040, "explicit use of destructor method")`
`32`		`- .span_label(span, &format!("call to destructor method"))`
	`32`	`+ .span_label(span, &format!("explicit destructor calls not allowed"))`
`33`	`33`	`.emit();`
`34`	`34`	`}`
`35`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1013,7 +1013,7 @@ fn check_impl_items_against_trait<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,`
`1013`	`1013`	`// We can only get the spans from local trait definition`
`1014`	`1014`	`// Same for E0324 and E0325`
`1015`	`1015`	`if let Some(trait_span) = tcx.map.span_if_local(ty_trait_item.def_id()) {`
`1016`		`- err.span_label(trait_span, &format!("original trait requirement"));`
	`1016`	`+ err.span_label(trait_span, &format!("item in trait"));`
`1017`	`1017`	`}`
`1018`	`1018`	`err.emit()`
`1019`	`1019`	`}`
`@@ -1041,7 +1041,7 @@ fn check_impl_items_against_trait<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,`
`1041`	`1041`	`impl_trait_ref);`
`1042`	`1042`	`err.span_label(impl_item.span, &format!("does not match trait"));`
`1043`	`1043`	`if let Some(trait_span) = tcx.map.span_if_local(ty_trait_item.def_id()) {`
`1044`		`- err.span_label(trait_span, &format!("original trait requirement"));`
	`1044`	`+ err.span_label(trait_span, &format!("item in trait"));`
`1045`	`1045`	`}`
`1046`	`1046`	`err.emit()`
`1047`	`1047`	`}`
`@@ -1064,7 +1064,7 @@ fn check_impl_items_against_trait<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,`
`1064`	`1064`	`impl_trait_ref);`
`1065`	`1065`	`err.span_label(impl_item.span, &format!("does not match trait"));`
`1066`	`1066`	`if let Some(trait_span) = tcx.map.span_if_local(ty_trait_item.def_id()) {`
`1067`		`- err.span_label(trait_span, &format!("original trait requirement"));`
	`1067`	`+ err.span_label(trait_span, &format!("item in trait"));`
`1068`	`1068`	`}`
`1069`	`1069`	`err.emit()`
`1070`	`1070`	`}`
`@@ -4408,8 +4408,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {`
`4408`	`4408`	`expected at most {}, found {}",`
`4409`	`4409`	`count(type_defs.len()),`
`4410`	`4410`	`count(types.len()))`
`4411`		`- .span_label(span, &format!("expected {}",`
`4412`		`- count(type_defs.len()))).emit();`
	`4411`	`+ .span_label(span, &format!("too many type parameters")).emit();`
`4413`	`4412`
`4414`	`4413`	`// To prevent derived errors to accumulate due to extra`
`4415`	`4414`	`// type parameters, we force instantiate_value_path to`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ impl<'cx, 'tcx> OrphanChecker<'cx, 'tcx> {`
`37`	`37`	"cannot define inherent `impl` for a type outside of the \
`38`	`38`	`crate where the type is defined")`
`39`	`39`	`.span_label(item.span, &format!("impl for type defined outside of crate."))`
`40`		`- .span_note(item.span, &format!("define and implement a trait or new type instead"))`
	`40`	`+ .note("define and implement a trait or new type instead")`
`41`	`41`	`.emit();`
`42`	`42`	`}`
`43`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -572,7 +572,7 @@ impl Foo for Bar {`
`572`	`572`	`// error, expected u16, found i16`
`573`	`573`	`fn foo(x: i16) { }`
`574`	`574`
`575`		`- // error, values differ in mutability`
	`575`	`+ // error, types differ in mutability`
`576`	`576`	`fn bar(&mut self) { }`
`577`	`577`	`}`
`578`	`578`	```
Original file line number	Diff line number	Diff line change
`@@ -22,5 +22,5 @@ fn main() {`
`22`	`22`	`let mut x = Foo { x: -7 };`
`23`	`23`	`x.drop();`
`24`	`24`	`//~^ ERROR E0040`
`25`		`- //~\| NOTE call to destructor method`
	`25`	`+ //~\| NOTE explicit destructor calls not allowed`
`26`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,5 +12,5 @@ fn foo<T>() {}`
`12`	`12`
`13`	`13`	`fn main() {`
`14`	`14`	`foo::<f64, bool>(); //~ ERROR E0087`
`15`		`- //~^ NOTE expected`
	`15`	`+ //~^ NOTE too many type parameters`
`16`	`16`	`}`