---

yaml
---
r: 220147
b: refs/heads/snap-stage3
c: c5f7c19
h: refs/heads/master
i:
  220145: 4396e41
  220143: 27c9d91
v: v3

Author: GuillaumeGomez

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: c044791d80ea0dc5c4b57b6030a67b69f8510239
-refs/heads/snap-stage3: f52a87c44e84a0089819e77ad85ea24b88d547e7
+refs/heads/snap-stage3: c5f7c19cf274f510b48d6835f5677ae22e978d6d
 refs/heads/try: b53c0f93eedcdedd4fd89bccc5a3a09d1c5cd23e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/snap-stage3/src/librustc_resolve/build_reduced_graph.rs

@@ -208,10 +208,13 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> {
                     // Return an error here by looking up the namespace that
                     // had the duplicate.
                     let ns = ns.unwrap();
-                    resolve_err!(self, sp, E0428,
-                                 "duplicate definition of {} `{}`",
-                                 namespace_error_to_string(duplicate_type),
-                                 token::get_name(name));
+                    ::resolve_error(
+                        &::ResolutionError::DuplicateDefinition(
+                            self,
+                            sp,
+                            namespace_error_to_string(duplicate_type),
+                            &*token::get_name(name))
+                    );
                     {
                         let r = child.span_for_namespace(ns);
                         if let Some(sp) = r {
@@ -304,9 +307,10 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> {
                             full_path.segments.last().unwrap().identifier.name;
                         if &token::get_name(source_name)[..] == "mod" ||
                            &token::get_name(source_name)[..] == "self" {
-                            resolve_err!(self, view_path.span, E0429,
-                                         "{}",
-                                         "`self` imports are only allowed within a { } list");
+                            ::resolve_error(&::ResolutionError::SelfImportsOnlyAllowedWithin(
+                                                                                self,
+                                                                                view_path.span)
+                            );
                         }
 
                         let subclass = SingleImport(binding.name,
@@ -326,9 +330,11 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> {
                             _ => None
                         }).collect::<Vec<Span>>();
                         if mod_spans.len() > 1 {
-                            resolve_err!(self, mod_spans[0], E0430,
-                                         "{}",
-                                         "`self` import can only appear once in the list");
+                            ::resolve_error(
+                                &::ResolutionError::SelfImportCanOnlyAppearOnceInTheList(
+                                    self,
+                                    mod_spans[0])
+                            );
                             for other_span in mod_spans.iter().skip(1) {
                                 self.session.span_note(*other_span,
                                     "another `self` import appears here");
@@ -343,10 +349,12 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> {
                                     let name = match module_path.last() {
                                         Some(name) => *name,
                                         None => {
-                                            resolve_err!(self, source_item.span, E0431,
-                                                "{}",
-                                                "`self` import can only appear in an import list \
-                                                 with a non-empty prefix");
+                                            ::resolve_error(
+                                                &::ResolutionError::
+                                                SelfImportOnlyInImportListWithNonEmptyPrefix(
+                                                    self,
+                                                    source_item.span)
+                                            );
                                             continue;
                                         }
                                     };