- remove syntax::{span_warn!, span_err!, span_fatal!. struct_err!}

- remove syntax::{help!, span_help!, span_note!}
- remove unused syntax::{struct_span_fatal, struct_span_err_or_warn!, span_err_or_warn!}
- lintify check_for_bindings_named_same_as_variants + conflicting_repr_hints
- inline syntax::{struct_span_warn!, diagnostic_used!}
- stringify_error_code! -> error_code! & use it more.
- find_plugin_registrar: de-fatalize an error
- de-fatalize metadata errors
- move type_error_struct! to rustc_typeck
- struct_span_err! -> rustc_errors

Author: Centril

Cargo.lock

@@ -3774,6 +3774,7 @@ version = "0.0.0"
 dependencies = [
  "rustc",
  "rustc_error_codes",
+ "rustc_errors",
  "rustc_metadata",
  "rustc_span",
  "syntax",
@@ -3787,6 +3788,7 @@ dependencies = [
  "rustc",
  "rustc_data_structures",
  "rustc_error_codes",
+ "rustc_errors",
  "rustc_span",
  "rustc_typeck",
  "syntax",

src/librustc/hir/check_attr.rs

@@ -8,11 +8,13 @@ use crate::hir::def_id::DefId;
 use crate::hir::intravisit::{self, NestedVisitorMap, Visitor};
 use crate::hir::DUMMY_HIR_ID;
 use crate::hir::{self, Attribute, HirId, Item, ItemKind, TraitItem, TraitItemKind};
-use crate::lint::builtin::UNUSED_ATTRIBUTES;
+use crate::lint::builtin::{CONFLICTING_REPR_HINTS, UNUSED_ATTRIBUTES};
 use crate::ty::query::Providers;
 use crate::ty::TyCtxt;
 
+use errors::{error_code, struct_span_err};
 use rustc_span::Span;
+
 use std::fmt::{self, Display};
 use syntax::{attr, symbol::sym};
 
@@ -192,7 +194,7 @@ impl CheckAttrVisitor<'tcx> {
             self.tcx.codegen_fn_attrs(self.tcx.hir().local_def_id(hir_id));
         }
 
-        self.check_repr(attrs, span, target, item);
+        self.check_repr(attrs, span, target, item, hir_id);
         self.check_used(attrs, target);
     }
 
@@ -353,6 +355,7 @@ impl CheckAttrVisitor<'tcx> {
         span: &Span,
         target: Target,
         item: Option<&Item<'_>>,
+        hir_id: HirId,
     ) {
         // Extract the names of all repr hints, e.g., [foo, bar, align] for:
         // ```
@@ -428,21 +431,29 @@ impl CheckAttrVisitor<'tcx> {
         // Error on repr(transparent, <anything else>).
         if is_transparent && hints.len() > 1 {
             let hint_spans: Vec<_> = hint_spans.clone().collect();
-            span_err!(
+            struct_span_err!(
                 self.tcx.sess,
                 hint_spans,
                 E0692,
                 "transparent {} cannot have other repr hints",
                 target
-            );
+            )
+            .emit();
         }
         // Warn on repr(u8, u16), repr(C, simd), and c-like-enum-repr(C, u8)
         if (int_reprs > 1)
             || (is_simd && is_c)
             || (int_reprs == 1 && is_c && item.map_or(false, |item| is_c_like_enum(item)))
         {
-            let hint_spans: Vec<_> = hint_spans.collect();
-            span_warn!(self.tcx.sess, hint_spans, E0566, "conflicting representation hints");
+            self.tcx
+                .struct_span_lint_hir(
+                    CONFLICTING_REPR_HINTS,
+                    hir_id,
+                    hint_spans.collect::<Vec<Span>>(),
+                    "conflicting representation hints",
+                )
+                .code(error_code!(E0566))
+                .emit();
         }
     }
 

src/librustc/infer/error_reporting/mod.rs

@@ -65,7 +65,7 @@ use crate::ty::{
     Region, Ty, TyCtxt, TypeFoldable,
 };
 
-use errors::{Applicability, DiagnosticBuilder, DiagnosticStyledString};
+use errors::{struct_span_err, Applicability, DiagnosticBuilder, DiagnosticStyledString};
 use rustc_error_codes::*;
 use rustc_span::{Pos, Span};
 use rustc_target::spec::abi;

src/librustc/infer/error_reporting/need_type_info.rs

@@ -5,7 +5,7 @@ use crate::infer::type_variable::TypeVariableOriginKind;
 use crate::infer::InferCtxt;
 use crate::ty::print::Print;
 use crate::ty::{self, DefIdTree, Infer, Ty, TyVar};
-use errors::{Applicability, DiagnosticBuilder};
+use errors::{struct_span_err, Applicability, DiagnosticBuilder};
 use rustc_span::Span;
 use std::borrow::Cow;
 use syntax::source_map::DesugaringKind;
@@ -153,14 +153,11 @@ pub enum TypeAnnotationNeeded {
 
 impl Into<errors::DiagnosticId> for TypeAnnotationNeeded {
     fn into(self) -> errors::DiagnosticId {
-        syntax::diagnostic_used!(E0282);
-        syntax::diagnostic_used!(E0283);
-        syntax::diagnostic_used!(E0284);
-        errors::DiagnosticId::Error(match self {
-            Self::E0282 => "E0282".to_string(),
-            Self::E0283 => "E0283".to_string(),
-            Self::E0284 => "E0284".to_string(),
-        })
+        match self {
+            Self::E0282 => errors::error_code!(E0282),
+            Self::E0283 => errors::error_code!(E0283),
+            Self::E0284 => errors::error_code!(E0284),
+        }
     }
 }
 

src/librustc/infer/error_reporting/nice_region_error/different_lifetimes.rs

@@ -5,6 +5,7 @@ use crate::infer::error_reporting::nice_region_error::util::AnonymousParamInfo;
 use crate::infer::error_reporting::nice_region_error::NiceRegionError;
 use crate::util::common::ErrorReported;
 
+use errors::struct_span_err;
 use rustc_error_codes::*;
 
 impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {

src/librustc/infer/error_reporting/nice_region_error/named_anon_conflict.rs

@@ -3,7 +3,7 @@
 use crate::hir::{FunctionRetTy, TyKind};
 use crate::infer::error_reporting::nice_region_error::NiceRegionError;
 use crate::ty;
-use errors::{Applicability, DiagnosticBuilder};
+use errors::{struct_span_err, Applicability, DiagnosticBuilder};
 
 use rustc_error_codes::*;
 

src/librustc/infer/error_reporting/note.rs

@@ -2,7 +2,7 @@ use crate::infer::{self, InferCtxt, SubregionOrigin};
 use crate::middle::region;
 use crate::ty::error::TypeError;
 use crate::ty::{self, Region};
-use errors::DiagnosticBuilder;
+use errors::{struct_span_err, DiagnosticBuilder};
 
 use rustc_error_codes::*;
 

src/librustc/infer/opaque_types/mod.rs

@@ -9,7 +9,7 @@ use crate::ty::fold::{BottomUpFolder, TypeFoldable, TypeFolder, TypeVisitor};
 use crate::ty::subst::{GenericArg, GenericArgKind, InternalSubsts, SubstsRef};
 use crate::ty::{self, GenericParamDefKind, Ty, TyCtxt};
 use crate::util::nodemap::DefIdMap;
-use errors::DiagnosticBuilder;
+use errors::{struct_span_err, DiagnosticBuilder};
 use rustc::session::config::nightly_options;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::sync::Lrc;
@@ -523,11 +523,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         err.span_label(span, label);
 
         if nightly_options::is_nightly_build() {
-            help!(
-                err,
-                "add #![feature(member_constraints)] to the crate attributes \
-                   to enable"
-            );
+            err.help("add #![feature(member_constraints)] to the crate attributes to enable");
         }
 
         err.emit();

src/librustc/lint/builtin.rs

@@ -95,6 +95,18 @@ declare_lint! {
     "detects overlapping patterns"
 }
 
+declare_lint! {
+    pub BINDING_VARIANT_NAME,
+    Warn,
+    "detects pattern bindings with the same name as one of the matched variants"
+}
+
+declare_lint! {
+    pub CONFLICTING_REPR_HINTS,
+    Warn,
+    "detects when more than one `#[repr(..)]` attribute, with different meaning, is applied"
+}
+
 declare_lint! {
     pub UNUSED_MACROS,
     Warn,
@@ -459,6 +471,7 @@ declare_lint_pass! {
         UNREACHABLE_CODE,
         UNREACHABLE_PATTERNS,
         OVERLAPPING_PATTERNS,
+        BINDING_VARIANT_NAME,
         UNUSED_MACROS,
         WARNINGS,
         UNUSED_FEATURES,

src/librustc/lint/context.rs

@@ -32,9 +32,9 @@ use crate::ty::{self, print::Printer, subst::GenericArg, Ty, TyCtxt};
 use crate::util::common::time;
 use crate::util::nodemap::FxHashMap;
 
-use errors::DiagnosticBuilder;
+use errors::{struct_span_err, DiagnosticBuilder};
 use rustc_data_structures::sync::{self, join, par_iter, ParallelIterator};
-use rustc_span::{symbol::Symbol, MultiSpan, Span};
+use rustc_span::{symbol::Symbol, MultiSpan, Span, DUMMY_SP};
 use std::slice;
 use syntax::ast;
 use syntax::util::lev_distance::find_best_match_for_name;
@@ -295,7 +295,8 @@ impl LintStore {
             CheckLintNameResult::Ok(_) => None,
             CheckLintNameResult::Warning(ref msg, _) => Some(sess.struct_warn(msg)),
             CheckLintNameResult::NoLint(suggestion) => {
-                let mut err = struct_err!(sess, E0602, "unknown lint: `{}`", lint_name);
+                let mut err =
+                    struct_span_err!(sess, DUMMY_SP, E0602, "unknown lint: `{}`", lint_name);
 
                 if let Some(suggestion) = suggestion {
                     err.help(&format!("did you mean: `{}`", suggestion));