Rollup merge of rust-lang#34531 - GuillaumeGomez:libsyntax_err_codes,…

… r=jonathandturner

Add error codes in libsyntax

r? @jonathandturner

Fixes rust-lang#34526

src/libsyntax/attr.rs

@@ -34,6 +34,27 @@ thread_local! {
  static USED_ATTRS: RefCell<Vec<u64>> = RefCell::new(Vec::new())
 }
 
+enum AttrError {
+ MultipleItem(InternedString),
+ UnknownMetaItem(InternedString),
+ MissingSince,
+ MissingFeature,
+ MultipleStabilityLevels,
+}
+
+fn handle_errors(diag: &Handler, span: Span, error: AttrError) {
+ match error {
+ AttrError::MultipleItem(item) => span_err!(diag, span, E0538,
+ "multiple '{}' items", item),
+ AttrError::UnknownMetaItem(item) => span_err!(diag, span, E0541,
+ "unknown meta item '{}'", item),
+ AttrError::MissingSince => span_err!(diag, span, E0542, "missing 'since'"),
+ AttrError::MissingFeature => span_err!(diag, span, E0546, "missing 'feature'"),
+ AttrError::MultipleStabilityLevels => span_err!(diag, span, E0544,
+ "multiple stability levels"),
+ }
+}
+
 pub fn mark_used(attr: &Attribute) {
  let AttrId(id) = attr.node.id;
  USED_ATTRS.with(|slot| {
@@ -303,10 +324,10 @@ pub fn find_export_name_attr(diag: &Handler, attrs: &[Attribute]) -> Option<Inte
  if let s@Some(_) = attr.value_str() {
  s
  } else {
- diag.struct_span_err(attr.span,
-  "export_name attribute has invalid format")
- .help("use #[export_name=\"*\"]")
- .emit();
+ struct_span_err!(diag, attr.span, E0533,
+ "export_name attribute has invalid format")
+  .help("use #[export_name=\"*\"]")
+  .emit();
  None
  }
  } else {
@@ -339,14 +360,16 @@ pub fn find_inline_attr(diagnostic: Option<&Handler>, attrs: &[Attribute]) -> In
  MetaItemKind::List(ref n, ref items) if n == "inline" => {
  mark_used(attr);
  if items.len() != 1 {
- diagnostic.map(|d|{ d.span_err(attr.span, "expected one argument"); });
+ diagnostic.map(|d|{ span_err!(d, attr.span, E0534, "expected one argument"); });
  InlineAttr::None
  } else if contains_name(&items[..], "always") {
  InlineAttr::Always
  } else if contains_name(&items[..], "never") {
  InlineAttr::Never
  } else {
- diagnostic.map(|d|{ d.span_err((*items[0]).span, "invalid argument"); });
+ diagnostic.map(|d| {
+ span_err!(d, (*items[0]).span, E0535, "invalid argument");
+ });
  InlineAttr::None
  }
  }
@@ -374,13 +397,13 @@ pub fn cfg_matches(cfgs: &[P<MetaItem>], cfg: &ast::MetaItem,
  mis.iter().all(|mi| cfg_matches(cfgs, &mi, sess, features)),
  ast::MetaItemKind::List(ref pred, ref mis) if &pred[..] == "not" => {
  if mis.len() != 1 {
- sess.span_diagnostic.span_err(cfg.span, "expected 1 cfg-pattern");
+ span_err!(sess.span_diagnostic, cfg.span, E0536, "expected 1 cfg-pattern");
  return false;
  }
  !cfg_matches(cfgs, &mis[0], sess, features)
  }
  ast::MetaItemKind::List(ref pred, _) => {
- sess.span_diagnostic.span_err(cfg.span, &format!("invalid predicate `{}`", pred));
+ span_err!(sess.span_diagnostic, cfg.span, E0537, "invalid predicate `{}`", pred);
  false
  },
  ast::MetaItemKind::Word(_) | ast::MetaItemKind::NameValue(..) => {
@@ -446,23 +469,23 @@ fn find_stability_generic<'a, I>(diagnostic: &Handler,
  if let Some(metas) = attr.meta_item_list() {
  let get = |meta: &MetaItem, item: &mut Option<InternedString>| {
  if item.is_some() {
- diagnostic.span_err(meta.span, &format!("multiple '{}' items",
- meta.name()));
+ handle_errors(diagnostic, meta.span, AttrError::MultipleItem(meta.name()));
  return false
  }
  if let Some(v) = meta.value_str() {
  *item = Some(v);
  true
  } else {
- diagnostic.span_err(meta.span, "incorrect meta item");
+ span_err!(diagnostic, meta.span, E0539, "incorrect meta item");
  false
  }
  };
 
  match tag {
  "rustc_deprecated" => {
  if rustc_depr.is_some() {
- diagnostic.span_err(item_sp, "multiple rustc_deprecated attributes");
+ span_err!(diagnostic, item_sp, E0540,
+ "multiple rustc_deprecated attributes");
  break
  }
 
@@ -473,8 +496,8 @@ fn find_stability_generic<'a, I>(diagnostic: &Handler,
  "since" => if !get(meta, &mut since) { continue 'outer },
  "reason" => if !get(meta, &mut reason) { continue 'outer },
  _ => {
- diagnostic.span_err(meta.span, &format!("unknown meta item '{}'",
-  meta.name()));
+ handle_errors(diagnostic, meta.span,
+ AttrError::UnknownMetaItem(meta.name()));
  continue 'outer
  }
  }
@@ -488,18 +511,18 @@ fn find_stability_generic<'a, I>(diagnostic: &Handler,
  })
  }
  (None, _) => {
- diagnostic.span_err(attr.span(), "missing 'since'");
+ handle_errors(diagnostic, attr.span(), AttrError::MissingSince);
  continue
  }
  _ => {
- diagnostic.span_err(attr.span(), "missing 'reason'");
+ span_err!(diagnostic, attr.span(), E0543, "missing 'reason'");
  continue
  }
  }
  }
  "unstable" => {
  if stab.is_some() {
- diagnostic.span_err(item_sp, "multiple stability levels");
+ handle_errors(diagnostic, attr.span(), AttrError::MultipleStabilityLevels);
  break
  }
 
@@ -512,8 +535,8 @@ fn find_stability_generic<'a, I>(diagnostic: &Handler,
  "reason" => if !get(meta, &mut reason) { continue 'outer },
  "issue" => if !get(meta, &mut issue) { continue 'outer },
  _ => {
- diagnostic.span_err(meta.span, &format!("unknown meta item '{}'",
-  meta.name()));
+ handle_errors(diagnostic, meta.span,
+ AttrError::UnknownMetaItem(meta.name()));
  continue 'outer
  }
  }
@@ -528,7 +551,8 @@ fn find_stability_generic<'a, I>(diagnostic: &Handler,
  if let Ok(issue) = issue.parse() {
  issue
  } else {
- diagnostic.span_err(attr.span(), "incorrect 'issue'");
+ span_err!(diagnostic, attr.span(), E0545,
+ "incorrect 'issue'");
  continue
  }
  }
@@ -538,18 +562,18 @@ fn find_stability_generic<'a, I>(diagnostic: &Handler,
  })
  }
  (None, _, _) => {
- diagnostic.span_err(attr.span(), "missing 'feature'");
+ handle_errors(diagnostic, attr.span(), AttrError::MissingFeature);
  continue
  }
  _ => {
- diagnostic.span_err(attr.span(), "missing 'issue'");
+ span_err!(diagnostic, attr.span(), E0547, "missing 'issue'");
  continue
  }
  }
  }
  "stable" => {
  if stab.is_some() {
- diagnostic.span_err(item_sp, "multiple stability levels");
+ handle_errors(diagnostic, attr.span(), AttrError::MultipleStabilityLevels);
  break
  }
 
@@ -560,8 +584,8 @@ fn find_stability_generic<'a, I>(diagnostic: &Handler,
  "feature" => if !get(meta, &mut feature) { continue 'outer },
  "since" => if !get(meta, &mut since) { continue 'outer },
  _ => {
- diagnostic.span_err(meta.span, &format!("unknown meta item '{}'",
-  meta.name()));
+ handle_errors(diagnostic, meta.span,
+ AttrError::UnknownMetaItem(meta.name()));
  continue 'outer
  }
  }
@@ -578,19 +602,19 @@ fn find_stability_generic<'a, I>(diagnostic: &Handler,
  })
  }
  (None, _) => {
- diagnostic.span_err(attr.span(), "missing 'feature'");
+ handle_errors(diagnostic, attr.span(), AttrError::MissingFeature);
  continue
  }
  _ => {
- diagnostic.span_err(attr.span(), "missing 'since'");
+ handle_errors(diagnostic, attr.span(), AttrError::MissingSince);
  continue
  }
  }
  }
  _ => unreachable!()
  }
  } else {
- diagnostic.span_err(attr.span(), "incorrect stability attribute type");
+ span_err!(diagnostic, attr.span(), E0548, "incorrect stability attribute type");
  continue
  }
  }
@@ -603,8 +627,9 @@ fn find_stability_generic<'a, I>(diagnostic: &Handler,
  }
  stab.rustc_depr = Some(rustc_depr);
  } else {
- diagnostic.span_err(item_sp, "rustc_deprecated attribute must be paired with \
- either stable or unstable attribute");
+ span_err!(diagnostic, item_sp, E0549,
+ "rustc_deprecated attribute must be paired with \
+ either stable or unstable attribute");
  }
  }
 
@@ -627,22 +652,21 @@ fn find_deprecation_generic<'a, I>(diagnostic: &Handler,
  mark_used(attr);
 
  if depr.is_some() {
- diagnostic.span_err(item_sp, "multiple deprecated attributes");
+ span_err!(diagnostic, item_sp, E0550, "multiple deprecated attributes");
  break
  }
 
  depr = if let Some(metas) = attr.meta_item_list() {
  let get = |meta: &MetaItem, item: &mut Option<InternedString>| {
  if item.is_some() {
- diagnostic.span_err(meta.span, &format!("multiple '{}' items",
- meta.name()));
+ handle_errors(diagnostic, meta.span, AttrError::MultipleItem(meta.name()));
  return false
  }
  if let Some(v) = meta.value_str() {
  *item = Some(v);
  true
  } else {
- diagnostic.span_err(meta.span, "incorrect meta item");
+ span_err!(diagnostic, meta.span, E0551, "incorrect meta item");
  false
  }
  };
@@ -654,8 +678,8 @@ fn find_deprecation_generic<'a, I>(diagnostic: &Handler,
  "since" => if !get(meta, &mut since) { continue 'outer },
  "note" => if !get(meta, &mut note) { continue 'outer },
  _ => {
- diagnostic.span_err(meta.span, &format!("unknown meta item '{}'",
-  meta.name()));
+ handle_errors(diagnostic, meta.span,
+ AttrError::UnknownMetaItem(meta.name()));
  continue 'outer
  }
  }
@@ -689,7 +713,7 @@ pub fn require_unique_names(diagnostic: &Handler, metas: &[P<MetaItem>]) {
 
  if !set.insert(name.clone()) {
  panic!(diagnostic.span_fatal(meta.span,
- &format!("duplicate meta item `{}`", name)));
+  &format!("duplicate meta item `{}`", name)));
  }
  }
 }
@@ -718,8 +742,8 @@ pub fn find_repr_attrs(diagnostic: &Handler, attr: &Attribute) -> Vec<ReprAttr>
  Some(ity) => Some(ReprInt(item.span, ity)),
  None => {
  // Not a word we recognize
- diagnostic.span_err(item.span,
-  "unrecognized representation hint");
+ span_err!(diagnostic, item.span, E0552,
+ "unrecognized representation hint");
  None
  }
  }
@@ -731,7 +755,8 @@ pub fn find_repr_attrs(diagnostic: &Handler, attr: &Attribute) -> Vec<ReprAttr>
  }
  }
  // Not a word:
- _ => diagnostic.span_err(item.span, "unrecognized enum representation hint")
+ _ => span_err!(diagnostic, item.span, E0553,
+ "unrecognized enum representation hint"),
  }
  }
  }

src/libsyntax/diagnostic_list.rs

@@ -0,0 +1,54 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![allow(non_snake_case)]
+
+// Error messages for EXXXX errors.
+// Each message should start and end with a new line, and be wrapped to 80 characters.
+// In vim you can `:set tw=80` and use `gq` to wrap paragraphs. Use `:set tw=0` to disable.
+register_long_diagnostics! {
+
+E0533: r##"
+```compile_fail,E0533
+#[export_name]
+pub fn something() {}
+
+fn main() {}
+```
+"##,
+
+}
+
+register_diagnostics! {
+ E0534, // expected one argument
+ E0535, // invalid argument
+ E0536, // expected 1 cfg-pattern
+ E0537, // invalid predicate
+ E0538, // multiple [same] items
+ E0539, // incorrect meta item
+ E0540, // multiple rustc_deprecated attributes
+ E0541, // unknown meta item
+ E0542, // missing 'since'
+ E0543, // missing 'reason'
+ E0544, // multiple stability levels
+ E0545, // incorrect 'issue'
+ E0546, // missing 'feature'
+ E0547, // missing 'issue'
+ E0548, // incorrect stability attribute type
+ E0549, // rustc_deprecated attribute must be paired with either stable or unstable attribute
+ E0550, // multiple deprecated attributes
+ E0551, // incorrect meta item
+ E0552, // unrecognized representation hint
+ E0553, // unrecognized enum representation hint
+ E0554, // #[feature] may not be used on the [] release channel
+ E0555, // malformed feature attribute, expected #![feature(...)]
+ E0556, // malformed feature, expected just one word
+ E0557, // feature has been removed
+}

src/libsyntax/feature_gate.rs

@@ -1103,17 +1103,16 @@ pub fn get_features(span_handler: &Handler, krate_attrs: &[ast::Attribute]) -> F
 
  match attr.meta_item_list() {
  None => {
- span_handler.span_err(attr.span, "malformed feature attribute, \
-   expected #![feature(...)]");
+ span_err!(span_handler, attr.span, E0555,
+ "malformed feature attribute, expected #![feature(...)]");
  }
  Some(list) => {
  for mi in list {
  let name = match mi.node {
  ast::MetaItemKind::Word(ref word) => (*word).clone(),
  _ => {
- span_handler.span_err(mi.span,
- "malformed feature, expected just \
- one word");
+ span_err!(span_handler, mi.span, E0556,
+ "malformed feature, expected just one word");
  continue
  }
  };
@@ -1123,7 +1122,7 @@ pub fn get_features(span_handler: &Handler, krate_attrs: &[ast::Attribute]) -> F
  }
  else if let Some(&(_, _, _)) = REMOVED_FEATURES.iter()
  .find(|& &(n, _, _)| name == n) {
- span_handler.span_err(mi.span, "feature has been removed");
+ span_err!(span_handler, mi.span, E0557, "feature has been removed");
  }
  else if let Some(&(_, _, _)) = ACCEPTED_FEATURES.iter()
  .find(|& &(n, _, _)| name == n) {
@@ -1179,9 +1178,9 @@ fn maybe_stage_features(span_handler: &Handler, krate: &ast::Crate,
  for attr in &krate.attrs {
  if attr.check_name("feature") {
  let release_channel = option_env!("CFG_RELEASE_CHANNEL").unwrap_or("(unknown)");
- let ref msg = format!("#[feature] may not be used on the {} release channel",
-  release_channel);
- span_handler.span_err(attr.span, msg);
+ span_err!(span_handler, attr.span, E0554,
+ "#[feature] may not be used on the {} release channel",
+  release_channel);
  }
  }
  }