---

yaml
---
r: 205038
b: refs/heads/tmp
c: 168615f
h: refs/heads/master
v: v3

Author: tbelaire

[refs]

@@ -32,7 +32,7 @@ refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
 refs/heads/beta: f0213d8ffb128a16f94af7ee985dc61484596163
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: 74648b5d647526e421d5015417968b64c1900512
+refs/heads/tmp: 168615f869ea560aa95e12a3c043c19110368be6
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: f0ac7e04e647381e2bb87de1f3d0b108acb24d06
 refs/heads/gate: 97c84447b65164731087ea82685580cc81424412

branches/tmp/src/librustc_resolve/resolve_imports.rs

@@ -618,7 +618,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
                                namespace_name,
                                name_bindings.def_for_namespace(namespace));
                         self.check_for_conflicting_import(
-                            &import_resolution.target_for_namespace(namespace),
+                            &import_resolution,
                             directive.span,
                             target,
                             namespace);
@@ -755,7 +755,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
                             // Continue.
                         }
                         Some(ref value_target) => {
-                            self.check_for_conflicting_import(&dest_import_resolution.value_target,
+                            self.check_for_conflicting_import(&dest_import_resolution,
                                                               import_directive.span,
                                                               *ident,
                                                               ValueNS);
@@ -767,7 +767,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
                             // Continue.
                         }
                         Some(ref type_target) => {
-                            self.check_for_conflicting_import(&dest_import_resolution.type_target,
+                            self.check_for_conflicting_import(&dest_import_resolution,
                                                               import_directive.span,
                                                               *ident,
                                                               TypeNS);
@@ -885,32 +885,29 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
 
     /// Checks that imported names and items don't have the same name.
     fn check_for_conflicting_import(&mut self,
-                                    target: &Option<Target>,
+                                    import_resolution: &ImportResolution,
                                     import_span: Span,
                                     name: Name,
                                     namespace: Namespace) {
+        let target = import_resolution.target_for_namespace(namespace);
         debug!("check_for_conflicting_import: {}; target exists: {}",
                &token::get_name(name),
                target.is_some());
 
-        match *target {
+        match target {
             Some(ref target) if target.shadowable != Shadowable::Always => {
-                let msg = format!("a {} named `{}` has already been imported \
-                                   in this module",
-                                  match namespace {
-                                    TypeNS => "type",
-                                    ValueNS => "value",
-                                  },
+                let ns_word = match namespace {
+                    TypeNS => "type",
+                    ValueNS => "value",
+                };
+                span_err!(self.resolver.session, import_span, E0252,
+                          "a {} named `{}` has already been imported \
+                           in this module", ns_word,
                                   &token::get_name(name));
-                span_err!(self.resolver.session, import_span, E0252, "{}", &msg[..]);
                 if let Some(sp) = target.bindings.span_for_namespace(namespace) {
                     span_note!(self.resolver.session, sp,
                                "first import of {} `{}` here",
-                               match namespace {
-                                   TypeNS => "type",
-                                   ValueNS => "value",
-                               },
-                               token::get_name(name));
+                               ns_word, token::get_name(name));
                 } else {
                     span_note!(self.resolver.session, import_span, "I can't find where it was previously imported");
                 }