Clean some error codes diagnostics

Author: GuillaumeGomez

src/librustc/middle/lib_features.rs

@@ -11,7 +11,8 @@ use syntax::ast::{Attribute, MetaItem, MetaItemKind};
 use syntax_pos::{Span, sym};
 use rustc_data_structures::fx::{FxHashSet, FxHashMap};
 use rustc_macros::HashStable;
-use errors::DiagnosticId;
+
+use rustc_error_codes::*;
 
 #[derive(HashStable)]
 pub struct LibFeatures {
@@ -98,15 +99,16 @@ impl LibFeatureCollector<'tcx> {
             (Some(since), _, false) => {
                 if let Some(prev_since) = self.lib_features.stable.get(&feature) {
                     if *prev_since != since {
-                        let msg = format!(
-                            "feature `{}` is declared stable since {}, \
-                             but was previously declared stable since {}",
-                            feature,
-                            since,
-                            prev_since,
+                        self.span_feature_error(
+                            span,
+                            &format!(
+                                "feature `{}` is declared stable since {}, \
+                                 but was previously declared stable since {}",
+                                feature,
+                                since,
+                                prev_since,
+                            ),
                         );
-                        self.tcx.sess.struct_span_err_with_code(span, &msg,
-                            DiagnosticId::Error("E0711".into())).emit();
                         return;
                     }
                 }
@@ -117,17 +119,27 @@ impl LibFeatureCollector<'tcx> {
                 self.lib_features.unstable.insert(feature);
             }
             (Some(_), _, true) | (None, true, _) => {
-                let msg = format!(
-                    "feature `{}` is declared {}, but was previously declared {}",
-                    feature,
-                    if since.is_some() { "stable" } else { "unstable" },
-                    if since.is_none() { "stable" } else { "unstable" },
+                self.span_feature_error(
+                    span,
+                    &format!(
+                        "feature `{}` is declared {}, but was previously declared {}",
+                        feature,
+                        if since.is_some() { "stable" } else { "unstable" },
+                        if since.is_none() { "stable" } else { "unstable" },
+                    ),
                 );
-                self.tcx.sess.struct_span_err_with_code(span, &msg,
-                    DiagnosticId::Error("E0711".into())).emit();
             }
         }
     }
+
+    fn span_feature_error(&self, span: Span, msg: &str) {
+        struct_span_err!(
+            self.tcx.sess,
+            span,
+            E0711,
+            "{}", &msg,
+        ).emit();
+    }
 }
 
 impl Visitor<'tcx> for LibFeatureCollector<'tcx> {

src/librustc_parse/parser/diagnostics.rs

@@ -12,7 +12,7 @@ use syntax::ThinVec;
 use syntax::util::parser::AssocOp;
 use syntax::struct_span_err;
 
-use errors::{PResult, Applicability, DiagnosticBuilder, DiagnosticId, pluralize};
+use errors::{PResult, Applicability, DiagnosticBuilder, pluralize};
 use rustc_data_structures::fx::FxHashSet;
 use syntax_pos::{Span, DUMMY_SP, MultiSpan, SpanSnippetError};
 use log::{debug, trace};
@@ -1413,19 +1413,19 @@ impl<'a> Parser<'a> {
         self.expect(&token::Colon)?;
         let ty = self.parse_ty()?;
 
-        self.diagnostic()
-            .struct_span_err_with_code(
-                pat.span,
-                "patterns aren't allowed in methods without bodies",
-                DiagnosticId::Error("E0642".into()),
-            )
-            .span_suggestion_short(
-                pat.span,
-                "give this argument a name or use an underscore to ignore it",
-                "_".to_owned(),
-                Applicability::MachineApplicable,
-            )
-            .emit();
+        struct_span_err!(
+            self.diagnostic(),
+            pat.span,
+            E0642,
+            "patterns aren't allowed in methods without bodies",
+        )
+        .span_suggestion_short(
+            pat.span,
+            "give this argument a name or use an underscore to ignore it",
+            "_".to_owned(),
+            Applicability::MachineApplicable,
+        )
+        .emit();
 
         // Pretend the pattern is `_`, to avoid duplicate errors from AST validation.
         let pat = P(Pat {

src/librustc_parse/parser/item.rs

@@ -14,12 +14,15 @@ use syntax::ThinVec;
 use syntax::token;
 use syntax::tokenstream::{TokenTree, TokenStream};
 use syntax::source_map::{self, respan, Span};
+use syntax::struct_span_err;
 use syntax_pos::BytePos;
 use syntax_pos::symbol::{kw, sym};
 
+use rustc_error_codes::*;
+
 use log::debug;
 use std::mem;
-use errors::{PResult, Applicability, DiagnosticBuilder, DiagnosticId, StashKey};
+use errors::{PResult, Applicability, DiagnosticBuilder, StashKey};
 
 /// Whether the type alias or associated type is a concrete type or an opaque type.
 #[derive(Debug)]
@@ -842,10 +845,11 @@ impl<'a> Parser<'a> {
                 if let token::DocComment(_) = self.token.kind {
                     if self.look_ahead(1,
                     |tok| tok == &token::CloseDelim(token::Brace)) {
-                        self.diagnostic().struct_span_err_with_code(
+                        struct_span_err!(
+                            self.diagnostic(),
                             self.token.span,
+                            E0584,
                             "found a documentation comment that doesn't document anything",
-                            DiagnosticId::Error("E0584".into()),
                         )
                         .help(
                             "doc comments must come before what they document, maybe a \

src/librustc_parse/parser/mod.rs

@@ -30,7 +30,7 @@ use syntax::util::comments::{doc_comment_style, strip_doc_comment_decoration};
 use syntax_pos::symbol::{kw, sym, Symbol};
 use syntax_pos::{Span, BytePos, DUMMY_SP, FileName};
 use rustc_data_structures::thin_vec::ThinVec;
-use errors::{PResult, Applicability, DiagnosticBuilder, DiagnosticId, FatalError};
+use errors::{PResult, Applicability, DiagnosticBuilder, FatalError};
 use log::debug;
 
 use std::borrow::Cow;
@@ -1251,13 +1251,13 @@ impl<'a> Parser<'a> {
     /// We are parsing `async fn`. If we are on Rust 2015, emit an error.
     fn ban_async_in_2015(&self, async_span: Span) {
         if async_span.rust_2015() {
-            self.diagnostic()
-                .struct_span_err_with_code(
-                    async_span,
-                    "`async fn` is not permitted in the 2015 edition",
-                    DiagnosticId::Error("E0670".into())
-                )
-                .emit();
+            struct_span_err!(
+                self.diagnostic(),
+                async_span,
+                E0670,
+                "`async fn` is not permitted in the 2015 edition",
+            )
+            .emit();
         }
     }
 

src/librustc_resolve/diagnostics.rs

@@ -1,6 +1,6 @@
 use std::cmp::Reverse;
 
-use errors::{Applicability, DiagnosticBuilder, DiagnosticId};
+use errors::{Applicability, DiagnosticBuilder};
 use log::debug;
 use rustc::bug;
 use rustc::hir::def::{self, DefKind, NonMacroAttrKind};
@@ -207,11 +207,11 @@ impl<'a> Resolver<'a> {
                 let origin_sp = origin.iter().copied().collect::<Vec<_>>();
 
                 let msp = MultiSpan::from_spans(target_sp.clone());
-                let msg = format!("variable `{}` is not bound in all patterns", name);
-                let mut err = self.session.struct_span_err_with_code(
+                let mut err = struct_span_err!(
+                    self.session,
                     msp,
-                    &msg,
-                    DiagnosticId::Error("E0408".into()),
+                    E0408,
+                    "variable `{}` is not bound in all patterns", name,
                 );
                 for sp in target_sp {
                     err.span_label(sp, format!("pattern doesn't bind `{}`", name));

src/librustc_typeck/check/wfcheck.rs

@@ -13,7 +13,7 @@ use syntax::ast;
 use syntax::feature_gate::{self, GateIssue};
 use syntax_pos::Span;
 use syntax::symbol::sym;
-use errors::{DiagnosticBuilder, DiagnosticId};
+use errors::DiagnosticBuilder;
 
 use rustc::hir::itemlikevisit::ParItemLikeVisitor;
 use rustc::hir;
@@ -847,12 +847,13 @@ fn check_method_receiver<'fcx, 'tcx>(
 }
 
 fn e0307(fcx: &FnCtxt<'fcx, 'tcx>, span: Span, receiver_ty: Ty<'_>) {
-    fcx.tcx.sess.diagnostic().struct_span_err(
+    struct_span_err!(
+        fcx.tcx.sess.diagnostic(),
         span,
-        &format!("invalid `self` parameter type: {:?}", receiver_ty)
+        E0307,
+        "invalid `self` parameter type: {:?}", receiver_ty,
     ).note("type of `self` must be `Self` or a type that dereferences to it")
     .help(HELP_FOR_SELF_TYPE)
-    .code(DiagnosticId::Error("E0307".into()))
     .emit();
 }
 

src/librustc_typeck/collect.rs

@@ -46,7 +46,7 @@ use rustc::hir::intravisit::{self, NestedVisitorMap, Visitor};
 use rustc::hir::GenericParamKind;
 use rustc::hir::{self, CodegenFnAttrFlags, CodegenFnAttrs, Unsafety};
 
-use errors::{Applicability, DiagnosticId, StashKey};
+use errors::{Applicability, StashKey};
 
 use rustc_error_codes::*;
 
@@ -160,10 +160,11 @@ impl Visitor<'tcx> for CollectItemTypesVisitor<'tcx> {
 // Utility types and common code for the above passes.
 
 fn bad_placeholder_type(tcx: TyCtxt<'tcx>, span: Span) -> errors::DiagnosticBuilder<'tcx> {
-    let mut diag = tcx.sess.struct_span_err_with_code(
+    let mut diag = struct_span_err!(
+        tcx.sess,
         span,
+        E0121,
         "the type placeholder `_` is not allowed within types on item signatures",
-        DiagnosticId::Error("E0121".into()),
     );
     diag.span_label(span, "not allowed in type signatures");
     diag