Add part of new error codes in librustc

src/librustc/diagnostics.rs

@@ -1886,7 +1886,52 @@ fn foo<'a>(arg: &Box<SomeTrait+'a>) { ... }
 contain references (with a maximum lifetime of `'a`).
 
 [1]: https://github.com/rust-lang/rfcs/pull/1156
-"##
+"##,
+
+E0454: r##"
+A link name was given with an empty name. Erroneous code example:
+
+```
+#[link(name = "")] extern {} // error: #[link(name = "")] given with empty name
+```
+
+The rust compiler cannot link to an external library if you don't give it its
+name. Example:
+
+```
+#[link(name = "some_lib")] extern {} // ok!
+```
+"##,
+
+E0458: r##"
+An unknown "kind" was specified for a link attribute. Erroneous code example:
+
+```
+#[link(kind = "wonderful_unicorn")] extern {}
+// error: unknown kind: `wonderful_unicorn`
+```
+
+Please specify a valid "kind" value, from one of the following:
+ * static
+ * dylib
+ * framework
+"##,
+
+E0459: r##"
+A link was used without a name parameter. Erroneous code example:
+
+```
+#[link(kind = "dylib")] extern {}
+// error: #[link(...)] specified without `name = "foo"`
+```
+
+Please add the name parameter to allow the rust compiler to find the library
+you want. Example:
+
+```
+#[link(kind = "dylib", name = "some_lib")] extern {} // ok!
+```
+"##,
 
 }
 
@@ -1913,5 +1958,42 @@ fn foo<'a>(arg: &Box<SomeTrait+'a>) { ... }
     E0314, // closure outlives stack frame
     E0315, // cannot invoke closure outside of its lifetime
     E0316, // nested quantification of lifetimes
-    E0400  // overloaded derefs are not allowed in constants
+    E0400, // overloaded derefs are not allowed in constants
+    E0452, // malformed lint attribute
+    E0453, // overruled by outer forbid
+    E0455, // native frameworks are only available on OSX targets
+    E0456, // plugin `..` is not available for triple `..`
+    E0457, // plugin `..` only found in rlib format, but must be available...
+    E0460, // found possibly newer version of crate `..`
+    E0461, // couldn't find crate `..` with expected target triple ..
+    E0462, // found staticlib `..` instead of rlib or dylib
+    E0463, // can't find crate for `..`
+    E0464, // multiple matching crates for `..`
+    E0465, // multiple .. candidates for `..` found
+    E0466, // bad macro import
+    E0467, // bad macro reexport
+    E0468, // an `extern crate` loading macros must be at the crate root
+    E0469, // imported macro not found
+    E0470, // reexported macro not found
+    E0471, // constant evaluation error: ..
+    E0472, // asm! is unsupported on this target
+    E0473, // dereference of reference outside its lifetime
+    E0474, // captured variable `..` does not outlive the enclosing closure
+    E0475, // index of slice outside its lifetime
+    E0476, // lifetime of the source pointer does not outlive lifetime bound...
+    E0477, // the type `..` does not fulfill the required lifetime...
+    E0478, // lifetime bound not satisfied
+    E0479, // the type `..` (provided as the value of a type parameter) is...
+    E0480, // lifetime of method receiver does not outlive the method call
+    E0481, // lifetime of function argument does not outlive the function call
+    E0482, // lifetime of return value does not outlive the function call
+    E0483, // lifetime of operand does not outlive the operation
+    E0484, // reference is not valid at the time of borrow
+    E0485, // automatically reference is not valid at the time of borrow
+    E0486, // type of expression contains references that are not valid during...
+    E0487, // unsafe use of destructor: destructor might be called while...
+    E0488, // lifetime of variable does not enclose its declaration
+    E0489, // type/lifetime parameter not in scope here
+    E0490, // a value of type `..` is borrowed for too long
+    E0491, // in type `..`, reference has a longer lifetime than the data it...
 }

src/librustc/lint/context.rs

@@ -467,7 +467,8 @@ fn with_lint_attrs<F>(&mut self,
         for result in gather_attrs(attrs) {
             let v = match result {
                 Err(span) => {
-                    self.tcx.sess.span_err(span, "malformed lint attribute");
+                    span_err!(self.tcx.sess, span, E0452,
+                              "malformed lint attribute");
                     continue;
                 }
                 Ok((lint_name, level, span)) => {
@@ -496,10 +497,10 @@ fn with_lint_attrs<F>(&mut self,
                 let now = self.lints.get_level_source(lint_id).0;
                 if now == Forbid && level != Forbid {
                     let lint_name = lint_id.as_str();
-                    self.tcx.sess.span_err(span,
-                                           &format!("{}({}) overruled by outer forbid({})",
-                                                   level.as_str(), lint_name,
-                                                   lint_name));
+                    span_err!(self.tcx.sess, span, E0453,
+                              "{}({}) overruled by outer forbid({})",
+                              level.as_str(), lint_name,
+                              lint_name);
                 } else if now != level {
                     let src = self.lints.get_level_source(lint_id).1;
                     self.level_stack.push((lint_id, (now, src)));

src/librustc/metadata/creader.rs

@@ -122,8 +122,8 @@ fn register_native_lib(sess: &Session,
     if name.is_empty() {
         match span {
             Some(span) => {
-                sess.span_err(span, "#[link(name = \"\")] given with \
-                                     empty name");
+                span_err!(sess, span, E0454,
+                          "#[link(name = \"\")] given with empty name");
             }
             None => {
                 sess.err("empty library name given via `-l`");
@@ -135,7 +135,10 @@ fn register_native_lib(sess: &Session,
     if kind == cstore::NativeFramework && !is_osx {
         let msg = "native frameworks are only available on OSX targets";
         match span {
-            Some(span) => sess.span_err(span, msg),
+            Some(span) => {
+                span_err!(sess, span, E0455,
+                          "{}", msg)
+            }
             None => sess.err(msg),
         }
     }
@@ -517,7 +520,7 @@ pub fn find_plugin_registrar(&mut self, span: Span, name: &str)
                                   name,
                                   config::host_triple(),
                                   self.sess.opts.target_triple);
-            self.sess.span_err(span, &message[..]);
+            span_err!(self.sess, span, E0456, "{}", &message[..]);
             self.sess.abort_if_errors();
         }
 
@@ -527,10 +530,10 @@ pub fn find_plugin_registrar(&mut self, span: Span, name: &str)
         match (ekrate.dylib.as_ref(), registrar) {
             (Some(dylib), Some(reg)) => Some((dylib.to_path_buf(), reg)),
             (None, Some(_)) => {
-                let message = format!("plugin `{}` only found in rlib format, \
-                                       but must be available in dylib format",
-                                       name);
-                self.sess.span_err(span, &message[..]);
+                span_err!(self.sess, span, E0457,
+                          "plugin `{}` only found in rlib format, but must be available \
+                           in dylib format",
+                          name);
                 // No need to abort because the loading code will just ignore this
                 // empty dylib.
                 None
@@ -763,7 +766,8 @@ fn process_foreign_mod(&mut self, i: &hir::Item, fm: &hir::ForeignMod) {
                 Some("dylib") => cstore::NativeUnknown,
                 Some("framework") => cstore::NativeFramework,
                 Some(k) => {
-                    self.sess.span_err(m.span, &format!("unknown kind: `{}`", k));
+                    span_err!(self.sess, m.span, E0458,
+                              "unknown kind: `{}`", k);
                     cstore::NativeUnknown
                 }
                 None => cstore::NativeUnknown
@@ -774,8 +778,8 @@ fn process_foreign_mod(&mut self, i: &hir::Item, fm: &hir::ForeignMod) {
             let n = match n {
                 Some(n) => n,
                 None => {
-                    self.sess.span_err(m.span, "#[link(...)] specified without \
-                                                `name = \"foo\"`");
+                    span_err!(self.sess, m.span, E0459,
+                              "#[link(...)] specified without `name = \"foo\"`");
                     InternedString::new("foo")
                 }
             };

src/librustc/metadata/loader.rs

@@ -308,23 +308,28 @@ pub fn load_library_crate(&mut self) -> Library {
     }
 
     pub fn report_load_errs(&mut self) {
-        let message = if !self.rejected_via_hash.is_empty() {
-            format!("found possibly newer version of crate `{}`",
-                    self.ident)
+        let add = match self.root {
+            &None => String::new(),
+            &Some(ref r) => format!(" which `{}` depends on",
+                                    r.ident)
+        };
+        if !self.rejected_via_hash.is_empty() {
+            span_err!(self.sess, self.span, E0460,
+                      "found possibly newer version of crate `{}`{}",
+                      self.ident, add);
         } else if !self.rejected_via_triple.is_empty() {
-            format!("couldn't find crate `{}` with expected target triple {}",
-                    self.ident, self.triple)
+            span_err!(self.sess, self.span, E0461,
+                      "couldn't find crate `{}` with expected target triple {}{}",
+                      self.ident, self.triple, add);
         } else if !self.rejected_via_kind.is_empty() {
-            format!("found staticlib `{}` instead of rlib or dylib", self.ident)
+            span_err!(self.sess, self.span, E0462,
+                      "found staticlib `{}` instead of rlib or dylib{}",
+                      self.ident, add);
         } else {
-            format!("can't find crate for `{}`", self.ident)
-        };
-        let message = match self.root {
-            &None => message,
-            &Some(ref r) => format!("{} which `{}` depends on",
-                                    message, r.ident)
-        };
-        self.sess.span_err(self.span, &message[..]);
+            span_err!(self.sess, self.span, E0463,
+                      "can't find crate for `{}`{}",
+                      self.ident, add);
+        }
 
         if !self.rejected_via_triple.is_empty() {
             let mismatches = self.rejected_via_triple.iter();
@@ -473,9 +478,9 @@ fn find_library_crate(&mut self) -> Option<Library> {
             0 => None,
             1 => Some(libraries.into_iter().next().unwrap()),
             _ => {
-                self.sess.span_err(self.span,
-                    &format!("multiple matching crates for `{}`",
-                            self.crate_name));
+                span_err!(self.sess, self.span, E0464,
+                          "multiple matching crates for `{}`",
+                          self.crate_name);
                 self.sess.note("candidates:");
                 for lib in &libraries {
                     match lib.dylib {
@@ -543,11 +548,9 @@ fn extract_one(&mut self, m: HashMap<PathBuf, PathKind>, flavor: &str,
                 }
             };
             if ret.is_some() {
-                self.sess.span_err(self.span,
-                                   &format!("multiple {} candidates for `{}` \
-                                            found",
-                                           flavor,
-                                           self.crate_name));
+                span_err!(self.sess, self.span, E0465,
+                          "multiple {} candidates for `{}` found",
+                          flavor, self.crate_name);
                 self.sess.span_note(self.span,
                                     &format!(r"candidate #1: {}",
                                             ret.as_ref().unwrap().0

src/librustc/metadata/macro_import.rs

@@ -41,6 +41,10 @@ fn new(sess: &'a Session) -> MacroLoader<'a> {
     }
 }
 
+pub fn call_bad_macro_reexport(a: &Session, b: Span) {
+    span_err!(a, b, E0467, "bad macro reexport");
+}
+
 /// Read exported macros.
 pub fn read_macro_defs(sess: &Session, krate: &ast::Crate) -> Vec<ast::MacroDef> {
     let mut loader = MacroLoader::new(sess);
@@ -91,7 +95,7 @@ fn visit_item(&mut self, item: &ast::Item) {
                             if let ast::MetaWord(ref name) = attr.node {
                                 sel.insert(name.clone(), attr.span);
                             } else {
-                                self.sess.span_err(attr.span, "bad macro import");
+                                span_err!(self.sess, attr.span, E0466, "bad macro import");
                             }
                         }
                     }
@@ -100,7 +104,7 @@ fn visit_item(&mut self, item: &ast::Item) {
                     let names = match attr.meta_item_list() {
                         Some(names) => names,
                         None => {
-                            self.sess.span_err(attr.span, "bad macro reexport");
+                            call_bad_macro_reexport(self.sess, attr.span);
                             continue;
                         }
                     };
@@ -109,7 +113,7 @@ fn visit_item(&mut self, item: &ast::Item) {
                         if let ast::MetaWord(ref name) = attr.node {
                             reexport.insert(name.clone(), attr.span);
                         } else {
-                            self.sess.span_err(attr.span, "bad macro reexport");
+                            call_bad_macro_reexport(self.sess, attr.span);
                         }
                     }
                 }
@@ -141,8 +145,8 @@ fn load_macros<'b>(&mut self,
         }
 
         if !self.span_whitelist.contains(&vi.span) {
-            self.sess.span_err(vi.span, "an `extern crate` loading macros must be at \
-                                         the crate root");
+            span_err!(self.sess, vi.span, E0468,
+                      "an `extern crate` loading macros must be at the crate root");
             return;
         }
 
@@ -167,14 +171,16 @@ fn load_macros<'b>(&mut self,
         if let Some(sel) = import.as_ref() {
             for (name, span) in sel {
                 if !seen.contains(&name) {
-                    self.sess.span_err(*span, "imported macro not found");
+                    span_err!(self.sess, *span, E0469,
+                              "imported macro not found");
                 }
             }
         }
 
         for (name, span) in &reexport {
             if !seen.contains(&name) {
-                self.sess.span_err(*span, "reexported macro not found");
+                span_err!(self.sess, *span, E0470,
+                          "reexported macro not found");
             }
         }
     }

src/librustc/middle/check_match.rs

@@ -282,9 +282,9 @@ fn check_for_static_nan(cx: &MatchCheckCtxt, pat: &Pat) {
 
                 Err(err) => {
                     let subspan = p.span.lo <= err.span.lo && err.span.hi <= p.span.hi;
-                    cx.tcx.sess.span_err(err.span,
-                                         &format!("constant evaluation error: {}",
-                                                  err.description()));
+                    span_err!(cx.tcx.sess, err.span, E0471,
+                              "constant evaluation error: {}",
+                              err.description());
                     if !subspan {
                         cx.tcx.sess.span_note(p.span,
                                               "in pattern here")

src/librustc/middle/check_no_asm.rs

@@ -32,8 +32,8 @@ struct CheckNoAsm<'a> {
 impl<'a, 'v> Visitor<'v> for CheckNoAsm<'a> {
     fn visit_expr(&mut self, e: &ast::Expr) {
         match e.node {
-            ast::ExprInlineAsm(_) => self.sess.span_err(e.span,
-                                                        "asm! is unsupported on this target"),
+            ast::ExprInlineAsm(_) => span_err!(self.sess, e.span, E0472,
+                                               "asm! is unsupported on this target"),
             _ => {},
         }
         visit::walk_expr(self, e)

src/librustc/middle/infer/error_reporting.rs

@@ -717,20 +717,17 @@ fn report_concrete_failure(&self,
                     "");
             }
             infer::DerefPointer(span) => {
-                self.tcx.sess.span_err(
-                    span,
-                    "dereference of reference outside its lifetime");
+                span_err!(self.tcx.sess, span, E0473,
+                          "dereference of reference outside its lifetime");
                 self.tcx.note_and_explain_region(
                     "the reference is only valid for ",
                     sup,
                     "");
             }
             infer::FreeVariable(span, id) => {
-                self.tcx.sess.span_err(
-                    span,
-                    &format!("captured variable `{}` does not \
-                              outlive the enclosing closure",
-                             self.tcx.local_var_name_str(id)));
+                span_err!(self.tcx.sess, span, E0474,
+                          "captured variable `{}` does not outlive the enclosing closure",
+                          self.tcx.local_var_name_str(id));
                 self.tcx.note_and_explain_region(
                     "captured variable is valid for ",
                     sup,
@@ -741,18 +738,17 @@ fn report_concrete_failure(&self,
                     "");
             }
             infer::IndexSlice(span) => {
-                self.tcx.sess.span_err(span,
-                                       "index of slice outside its lifetime");
+                span_err!(self.tcx.sess, span, E0475,
+                          "index of slice outside its lifetime");
                 self.tcx.note_and_explain_region(
                     "the slice is only valid for ",
                     sup,
                     "");
             }
             infer::RelateObjectBound(span) => {
-                self.tcx.sess.span_err(
-                    span,
-                    "lifetime of the source pointer does not outlive \
-                     lifetime bound of the object type");
+                span_err!(self.tcx.sess, span, E0476,
+                          "lifetime of the source pointer does not outlive \
+                           lifetime bound of the object type");
                 self.tcx.note_and_explain_region(
                     "object type is valid for ",
                     sub,
@@ -763,20 +759,17 @@ fn report_concrete_failure(&self,
                     "");
             }
             infer::RelateParamBound(span, ty) => {
-                self.tcx.sess.span_err(
-                    span,
-                    &format!("the type `{}` does not fulfill the \
-                             required lifetime",
-                            self.ty_to_string(ty)));
+                span_err!(self.tcx.sess, span, E0477,
+                          "the type `{}` does not fulfill the required lifetime",
+                          self.ty_to_string(ty));
                 self.tcx.note_and_explain_region(
                                         "type must outlive ",
                                         sub,
                                         "");
             }
             infer::RelateRegionParamBound(span) => {
-                self.tcx.sess.span_err(
-                    span,
-                    "lifetime bound not satisfied");
+                span_err!(self.tcx.sess, span, E0478,
+                          "lifetime bound not satisfied");
                 self.tcx.note_and_explain_region(
                     "lifetime parameter instantiated with ",
                     sup,
@@ -787,92 +780,82 @@ fn report_concrete_failure(&self,
                     "");
             }
             infer::RelateDefaultParamBound(span, ty) => {
-                self.tcx.sess.span_err(
-                    span,
-                    &format!("the type `{}` (provided as the value of \
-                             a type parameter) is not valid at this point",
-                            self.ty_to_string(ty)));
+                span_err!(self.tcx.sess, span, E0479,
+                          "the type `{}` (provided as the value of \
+                           a type parameter) is not valid at this point",
+                          self.ty_to_string(ty));
                 self.tcx.note_and_explain_region(
                                         "type must outlive ",
                                         sub,
                                         "");
             }
             infer::CallRcvr(span) => {
-                self.tcx.sess.span_err(
-                    span,
-                    "lifetime of method receiver does not outlive \
-                     the method call");
+                span_err!(self.tcx.sess, span, E0480,
+                          "lifetime of method receiver does not outlive \
+                           the method call");
                 self.tcx.note_and_explain_region(
                     "the receiver is only valid for ",
                     sup,
                     "");
             }
             infer::CallArg(span) => {
-                self.tcx.sess.span_err(
-                    span,
-                    "lifetime of function argument does not outlive \
-                     the function call");
+                span_err!(self.tcx.sess, span, E0481,
+                          "lifetime of function argument does not outlive \
+                           the function call");
                 self.tcx.note_and_explain_region(
                     "the function argument is only valid for ",
                     sup,
                     "");
             }
             infer::CallReturn(span) => {
-                self.tcx.sess.span_err(
-                    span,
-                    "lifetime of return value does not outlive \
-                     the function call");
+                span_err!(self.tcx.sess, span, E0482,
+                          "lifetime of return value does not outlive \
+                           the function call");
                 self.tcx.note_and_explain_region(
                     "the return value is only valid for ",
                     sup,
                     "");
             }
             infer::Operand(span) => {
-                self.tcx.sess.span_err(
-                    span,
-                    "lifetime of operand does not outlive \
-                     the operation");
+                span_err!(self.tcx.sess, span, E0483,
+                          "lifetime of operand does not outlive \
+                           the operation");
                 self.tcx.note_and_explain_region(
                     "the operand is only valid for ",
                     sup,
                     "");
             }
             infer::AddrOf(span) => {
-                self.tcx.sess.span_err(
-                    span,
-                    "reference is not valid \
-                     at the time of borrow");
+                span_err!(self.tcx.sess, span, E0484,
+                          "reference is not valid at the time of borrow");
                 self.tcx.note_and_explain_region(
                     "the borrow is only valid for ",
                     sup,
                     "");
             }
             infer::AutoBorrow(span) => {
-                self.tcx.sess.span_err(
-                    span,
-                    "automatically reference is not valid \
-                     at the time of borrow");
+                span_err!(self.tcx.sess, span, E0485,
+                          "automatically reference is not valid \
+                           at the time of borrow");
                 self.tcx.note_and_explain_region(
                     "the automatic borrow is only valid for ",
                     sup,
                     "");
             }
             infer::ExprTypeIsNotInScope(t, span) => {
-                self.tcx.sess.span_err(
-                    span,
-                    &format!("type of expression contains references \
-                             that are not valid during the expression: `{}`",
-                            self.ty_to_string(t)));
+                span_err!(self.tcx.sess, span, E0486,
+                          "type of expression contains references \
+                           that are not valid during the expression: `{}`",
+                          self.ty_to_string(t));
                 self.tcx.note_and_explain_region(
                     "type is only valid for ",
                     sup,
                     "");
             }
             infer::SafeDestructor(span) => {
-                self.tcx.sess.span_err(
-                    span,
-                    "unsafe use of destructor: destructor might be called \
-                     while references are dead");
+                span_err!(self.tcx.sess, span, E0487,
+                          "unsafe use of destructor: destructor might be called \
+                           while references are dead");
                 // FIXME (22171): terms "super/subregion" are suboptimal
                 self.tcx.note_and_explain_region(
                     "superregion: ",
@@ -884,37 +867,33 @@ fn report_concrete_failure(&self,
                     "");
             }
             infer::BindingTypeIsNotValidAtDecl(span) => {
-                self.tcx.sess.span_err(
-                    span,
-                    "lifetime of variable does not enclose its declaration");
+                span_err!(self.tcx.sess, span, E0488,
+                          "lifetime of variable does not enclose its declaration");
                 self.tcx.note_and_explain_region(
                     "the variable is only valid for ",
                     sup,
                     "");
             }
             infer::ParameterInScope(_, span) => {
-                self.tcx.sess.span_err(
-                    span,
-                    &format!("type/lifetime parameter not in scope here"));
+                span_err!(self.tcx.sess, span, E0489,
+                          "type/lifetime parameter not in scope here");
                 self.tcx.note_and_explain_region(
                     "the parameter is only valid for ",
                     sub,
                     "");
             }
             infer::DataBorrowed(ty, span) => {
-                self.tcx.sess.span_err(
-                    span,
-                    &format!("a value of type `{}` is borrowed for too long",
-                             self.ty_to_string(ty)));
+                span_err!(self.tcx.sess, span, E0490,
+                          "a value of type `{}` is borrowed for too long",
+                          self.ty_to_string(ty));
                 self.tcx.note_and_explain_region("the type is valid for ", sub, "");
                 self.tcx.note_and_explain_region("but the borrow lasts for ", sup, "");
             }
             infer::ReferenceOutlivesReferent(ty, span) => {
-                self.tcx.sess.span_err(
-                    span,
-                    &format!("in type `{}`, reference has a longer lifetime \
-                             than the data it references",
-                            self.ty_to_string(ty)));
+                span_err!(self.tcx.sess, span, E0491,
+                          "in type `{}`, reference has a longer lifetime \
+                           than the data it references",
+                          self.ty_to_string(ty));
                 self.tcx.note_and_explain_region(
                     "the pointer is valid for ",
                     sub,
@@ -1778,7 +1757,7 @@ fn note_region_origin(&self, origin: &SubregionOrigin<'tcx>) {
                     "...so that return value is valid for the call");
             }
             infer::Operand(span) => {
-                self.tcx.sess.span_err(
+                self.tcx.sess.span_note(
                     span,
                     "...so that operand is valid for operation");
             }