Update Error format for E0164, E0165, E0184

src/librustc_const_eval/check_match.rs

@@ -324,7 +324,10 @@ fn check_arms(cx: &MatchCheckCtxt,
                             let &(ref first_arm_pats, _) = &arms[0];
                             let first_pat = &first_arm_pats[0];
                             let span = first_pat.span;
-                            span_err!(cx.tcx.sess, span, E0165, "irrefutable while-let pattern");
+                            struct_span_err!(cx.tcx.sess, span, E0165,
+                                             "irrefutable while-let pattern")
+                                .span_label(span, &format!("irrefutable pattern"))
+                                .emit();
                         },
 
                         hir::MatchSource::ForLoopDesugar => {

src/librustc_typeck/check/_match.rs

@@ -574,7 +574,8 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                 tcx.sess.add_lint(lint::builtin::MATCH_OF_UNIT_VARIANT_VIA_PAREN_DOTDOT,
                                   pat.id, pat.span, msg);
             } else {
-                span_err!(tcx.sess, pat.span, E0164, "{}", msg);
+                struct_span_err!(tcx.sess, pat.span, E0164, "{}", msg)
+                    .span_label(pat.span, &format!("not a tuple variant or struct")).emit();
                 on_error();
             }
         };

src/librustc_typeck/coherence/mod.rs

@@ -348,9 +348,11 @@ impl<'a, 'gcx, 'tcx> CoherenceChecker<'a, 'gcx, 'tcx> {
                         .emit();
                 }
                 Err(CopyImplementationError::HasDestructor) => {
-                    span_err!(tcx.sess, span, E0184,
+                    struct_span_err!(tcx.sess, span, E0184,
                               "the trait `Copy` may not be implemented for this type; \
-                               the type has a destructor");
+                               the type has a destructor")
+                        .span_label(span, &format!("Copy not allowed on types with destructors"))
+                        .emit();
                 }
             }
         });

src/test/compile-fail/E0164.rs

@@ -13,6 +13,7 @@ enum Foo { B { i: u32 } }
 fn bar(foo: Foo) -> u32 {
     match foo {
         Foo::B(i) => i, //~ ERROR E0164
+                        //~| NOTE not a tuple variant or struct
     }
 }
 

src/test/compile-fail/E0165.rs

@@ -13,6 +13,7 @@ struct Irrefutable(i32);
 fn main() {
     let irr = Irrefutable(0);
     while let Irrefutable(x) = irr { //~ ERROR E0165
+                                     //~| irrefutable pattern
         // ...
     }
 }

src/test/compile-fail/E0184.rs

@@ -9,6 +9,8 @@
 // except according to those terms.
 
 #[derive(Copy)] //~ ERROR E0184
+                //~| NOTE Copy not allowed on types with destructors
+                //~| NOTE in this expansion of #[derive(Copy)]
 struct Foo;
 
 impl Drop for Foo {