Update error codes

Author: GuillaumeGomez

src/librustc_resolve/diagnostics.rs

@@ -210,10 +210,6 @@ register_diagnostics! {
     E0258,
     E0364, // item is private
     E0365, // item is private
-    E0397, // failed to resolve
-    E0398, // unresolved import
-    E0399, // can't capture dynamic environment in a fn item
-    E0400, // attempt to use a non-constant value in a constant
     E0401, // can't use type parameters from outer function
     E0402, // cannot use an outer type parameter in this context
     E0403, // the name `{}` is already used
@@ -248,6 +244,10 @@ register_diagnostics! {
     E0428, // duplicate definition of ...
     E0429, // `self` imports are only allowed within a { } list
     E0430, // `self` import can only appear once in the list
-    E0431  // `self` import can only appear in an import list with a non-empty
+    E0431, // `self` import can only appear in an import list with a non-empty
            // prefix
+    E0432, // unresolved import
+    E0433, // failed to resolve
+    E0434, // can't capture dynamic environment in a fn item
+    E0435  // attempt to use a non-constant value in a constant
 }

src/librustc_resolve/lib.rs

@@ -1310,7 +1310,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                                               PathSearch,
                                               true) {
                 Failed(Some((span, msg))) => {
-                    resolve_err!(self, span, E0397, "failed to resolve. {}", msg);
+                    resolve_err!(self, span, E0433, "failed to resolve. {}", msg);
                 },
                 Failed(None) => (), // Continue up the search chain.
                 Indeterminate => {
@@ -1568,10 +1568,10 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                          .span_to_snippet((*imports)[index].span)
                          .unwrap();
             if sn.contains("::") {
-                resolve_err!(self, (*imports)[index].span, E0398,
+                resolve_err!(self, (*imports)[index].span, E0432,
                              "{}", "unresolved import");
             } else {
-                resolve_err!(self, (*imports)[index].span, E0398,
+                resolve_err!(self, (*imports)[index].span, E0432,
                              "unresolved import (maybe you meant `{}::*`?)", sn);
             }
         }
@@ -1698,14 +1698,14 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                             // This was an attempt to access an upvar inside a
                             // named function item. This is not allowed, so we
                             // report an error.
-                            resolve_err!(self, span, E0399, "{}",
+                            resolve_err!(self, span, E0434, "{}",
                                          "can't capture dynamic environment in a fn item; \
                                           use the || { ... } closure form instead");
                             return None;
                         }
                         ConstantItemRibKind => {
                             // Still doesn't deal with upvars
-                            resolve_err!(self, span, E0400, "{}",
+                            resolve_err!(self, span, E0435, "{}",
                                          "attempt to use a non-constant \
                                           value in a constant");
                             return None;
@@ -2678,7 +2678,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
             Failed(err) => {
                 match err {
                     Some((span, msg)) => {
-                        resolve_err!(self, span, E0397,
+                        resolve_err!(self, span, E0433,
                                      "failed to resolve: {}",
                                      msg);
                     }
@@ -2909,7 +2909,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                     }
                 };
 
-                resolve_err!(self, span, E0397,
+                resolve_err!(self, span, E0433,
                              "failed to resolve: {}",
                              msg);
                 return None;
@@ -2972,7 +2972,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
 
                 /*self.resolve_error(span, &format!("failed to resolve. {}",
                                                  msg));*/
-                resolve_err!(self, span, E0397,
+                resolve_err!(self, span, E0433,
                              "failed to resolve: {}",
                              msg);
                 return None;
@@ -3070,7 +3070,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                          failed to resolve {}", name);
 
                 if let Some((span, msg)) = err {
-                    resolve_err!(self, span, E0397,
+                    resolve_err!(self, span, E0433,
                                  "failed to resolve: {}",
                                  msg)
                 }

src/librustc_resolve/resolve_imports.rs

@@ -272,7 +272,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
                         Some((span, msg)) => (span, format!(". {}", msg)),
                         None => (import_directive.span, String::new())
                     };
-                    resolve_err!(self.resolver, span, E0398,
+                    resolve_err!(self.resolver, span, E0432,
                                  "unresolved import `{}`{}",
                                  import_path_to_string(
                                           &import_directive.module_path,