Add part of new error codes in librustc

3 files changed, 53 insertions, 40 deletions

diff --git a/src/librustc/metadata/creader.rs b/src/librustc/metadata/creader.rs
index 5ac84578369..c8298c3504c 100644
--- a/src/librustc/metadata/creader.rs
+++ b/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 @@ impl<'a> CrateReader<'a> {
                                   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 @@ impl<'a> CrateReader<'a> {
         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 @@ impl<'a, 'b> LocalCrateReader<'a, 'b> {
                 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 @@ impl<'a, 'b> LocalCrateReader<'a, 'b> {
             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")
                 }
             };
diff --git a/src/librustc/metadata/loader.rs b/src/librustc/metadata/loader.rs
index 2f481f70aaf..99d1eaebdb2 100644
--- a/src/librustc/metadata/loader.rs
+++ b/src/librustc/metadata/loader.rs
@@ -308,23 +308,28 @@ impl<'a> Context<'a> {
     }
 
     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 @@ impl<'a> Context<'a> {
             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 @@ impl<'a> Context<'a> {
                 }
             };
             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
diff --git a/src/librustc/metadata/macro_import.rs b/src/librustc/metadata/macro_import.rs
index 527f5919e2d..5105426392b 100644
--- a/src/librustc/metadata/macro_import.rs
+++ b/src/librustc/metadata/macro_import.rs
@@ -41,6 +41,10 @@ impl<'a> 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 @@ impl<'a, 'v> Visitor<'v> for MacroLoader<'a> {
                             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 @@ impl<'a, 'v> Visitor<'v> for MacroLoader<'a> {
                     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 @@ impl<'a, 'v> Visitor<'v> for MacroLoader<'a> {
                         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 @@ impl<'a> MacroLoader<'a> {
         }
 
         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 @@ impl<'a> MacroLoader<'a> {
         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");
             }
         }
     }