Remove token::get_name when unneeded

diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
index 5d10b0d9a57b80b31990b6221e44f1cc87370e54..f879f1c09f68a2eec047b90d820a80d31c8b7905 100644 (file)
--- a/src/librustc_resolve/lib.rs
+++ b/src/librustc_resolve/lib.rs
@@ -109,6 +109,14 @@
 mod build_reduced_graph;
 mod resolve_imports;
 
+macro_rules! resolve_err {
+    ($this:expr, $($rest:tt)*) => {
+        if $this.emit_errors {
+            span_err!($this.session, $($rest)*);
+        }
+    }
+}
+
 #[derive(Copy, Clone)]
 struct BindingInfo {
     span: Span,
@@ -947,8 +955,8 @@ fn check_for_conflicts_between_external_crates(&self,
         if module.external_module_children.borrow().contains_key(&name) {
                 span_err!(self.session, span, E0259,
                           "an external crate named `{}` has already \
-                                   been imported into this module",
-                                  &token::get_name(name));
+                           been imported into this module",
+                          name);
         }
     }
 
@@ -960,9 +968,9 @@ fn check_for_conflicts_between_external_crates_and_items(&self,
         if module.external_module_children.borrow().contains_key(&name) {
                 span_err!(self.session, span, E0260,
                           "the name `{}` conflicts with an external \
-                                   crate that has been imported into this \
-                                   module",
-                                  &token::get_name(name));
+                           crate that has been imported into this \
+                           module",
+                           name);
         }
     }
 
@@ -1041,7 +1049,7 @@ fn search_parent_externals(needle: Name, module: &Rc<Module>)
                 Indeterminate => {
                     debug!("(resolving module path for import) module \
                             resolution is indeterminate: {}",
-                            token::get_name(name));
+                            name);
                     return Indeterminate;
                 }
                 Success((target, used_proxy)) => {
@@ -1052,7 +1060,7 @@ fn search_parent_externals(needle: Name, module: &Rc<Module>)
                             match type_def.module_def {
                                 None => {
                                     let msg = format!("Not a module `{}`",
-                                                        token::get_name(name));
+                                                        name);
 
                                     return Failed(Some((span, msg)));
                                 }
@@ -1078,7 +1086,7 @@ fn search_parent_externals(needle: Name, module: &Rc<Module>)
                         None => {
                             // There are no type bindings at all.
                             let msg = format!("Not a module `{}`",
-                                              token::get_name(name));
+                                              name);
                             return Failed(Some((span, msg)));
                         }
                     }
@@ -1200,7 +1208,7 @@ fn resolve_item_in_lexical_scope(&mut self,
                                     -> ResolveResult<(Target, bool)> {
         debug!("(resolving item in lexical scope) resolving `{}` in \
                 namespace {:?} in `{}`",
-               token::get_name(name),
+               name,
                namespace,
                module_to_string(&*module_));
 
@@ -1302,9 +1310,11 @@ fn resolve_item_in_lexical_scope(&mut self,
                                               namespace,
                                               PathSearch,
                                               true) {
-                Failed(Some((span, msg))) =>
-                    self.resolve_error(span, &format!("failed to resolve. {}",
-                                                     msg)),
+                Failed(Some((span, msg))) => {
+                    self.resolve_error(span,
+                                       &format!("failed to resolve. {}",
+                                                msg));
+                },
                 Failed(None) => (), // Continue up the search chain.
                 Indeterminate => {
                     // We couldn't see through the higher scope because of an
@@ -1469,7 +1479,7 @@ fn resolve_name_in_module(&mut self,
                               allow_private_imports: bool)
                               -> ResolveResult<(Target, bool)> {
         debug!("(resolving name in module) resolving `{}` in `{}`",
-               &token::get_name(name),
+               name,
                module_to_string(&*module_));
 
         // First, check the direct children of the module.
@@ -1547,7 +1557,7 @@ fn resolve_name_in_module(&mut self,
 
         // We're out of luck.
         debug!("(resolving name in module) failed to resolve `{}`",
-               &token::get_name(name));
+               name);
         return Failed(None);
     }
 
@@ -1623,7 +1633,7 @@ fn with_scope<F>(&mut self, name: Option<Name>, f: F) where
                 match orig_module.children.borrow().get(&name) {
                     None => {
                         debug!("!!! (with scope) didn't find `{}` in `{}`",
-                               token::get_name(name),
+                               name,
                                module_to_string(&*orig_module));
                     }
                     Some(name_bindings) => {
@@ -1631,7 +1641,7 @@ fn with_scope<F>(&mut self, name: Option<Name>, f: F) where
                             None => {
                                 debug!("!!! (with scope) didn't find module \
                                         for `{}` in `{}`",
-                                       token::get_name(name),
+                                       name,
                                        module_to_string(&*orig_module));
                             }
                             Some(module_) => {
@@ -1795,7 +1805,7 @@ fn resolve_item(&mut self, item: &Item) {
         let name = item.ident.name;
 
         debug!("(resolving item) resolving {}",
-               token::get_name(name));
+               name);
 
         match item.node {
             ItemEnum(_, ref generics) |
@@ -1931,7 +1941,7 @@ fn with_type_parameter_rib<F>(&mut self, type_parameters: TypeParameters, f: F)
                                                      used for a type \
                                                      parameter in this type \
                                                      parameter list",
-                                                    token::get_name(name)))
+                                                    name))
                     }
                     seen_bindings.insert(name);
 
@@ -2177,7 +2187,7 @@ fn check_trait_item(&self, name: Name, span: Span) {
                 let path_str = path_names_to_string(&trait_ref.path, 0);
                 self.resolve_error(span,
                                     &format!("method `{}` is not a member of trait `{}`",
-                                            token::get_name(name),
+                                            name,
                                             path_str));
             }
         }
@@ -2229,7 +2239,7 @@ fn check_consistent_bindings(&mut self, arm: &Arm) {
                         p.span,
                         &format!("variable `{}` from pattern #1 is \
                                   not bound in pattern #{}",
-                                token::get_name(key),
+                                key,
                                 i + 1));
                   }
                   Some(binding_i) => {
@@ -2238,7 +2248,7 @@ fn check_consistent_bindings(&mut self, arm: &Arm) {
                             binding_i.span,
                             &format!("variable `{}` is bound with different \
                                       mode in pattern #{} than in pattern #1",
-                                    token::get_name(key),
+                                    key,
                                     i + 1));
                     }
                   }
@@ -2251,7 +2261,7 @@ fn check_consistent_bindings(&mut self, arm: &Arm) {
                         binding.span,
                         &format!("variable `{}` from pattern {}{} is \
                                   not bound in pattern {}1",
-                                token::get_name(key),
+                                key,
                                 "#", i + 1, "#"));
                 }
             }
@@ -2410,7 +2420,7 @@ fn resolve_pattern(&mut self,
                                 if mode == RefutableMode => {
                             debug!("(resolving pattern) resolving `{}` to \
                                     struct or enum variant",
-                                   token::get_name(renamed));
+                                   renamed);
 
                             self.enforce_default_binding_mode(
                                 pattern,
@@ -2428,12 +2438,12 @@ struct or enum variant",
                                 &format!("declaration of `{}` shadows an enum \
                                          variant or unit-like struct in \
                                          scope",
-                                        token::get_name(renamed)));
+                                        renamed));
                         }
                         FoundConst(def, lp) if mode == RefutableMode => {
                             debug!("(resolving pattern) resolving `{}` to \
                                     constant",
-                                   token::get_name(renamed));
+                                   renamed);
 
                             self.enforce_default_binding_mode(
                                 pattern,
@@ -2452,7 +2462,7 @@ struct or enum variant",
                         }
                         BareIdentifierPatternUnresolved => {
                             debug!("(resolving pattern) binding `{}`",
-                                   token::get_name(renamed));
+                                   renamed);
 
                             let def = DefLocal(pattern.id);
 
@@ -2639,7 +2649,7 @@ fn resolve_bare_identifier_pattern(&mut self, name: Name, span: Span)
             Success((target, _)) => {
                 debug!("(resolve bare identifier pattern) succeeded in \
                          finding {} at {:?}",
-                        token::get_name(name),
+                        name,
                         target.bindings.value_def.borrow());
                 match *target.bindings.value_def.borrow() {
                     None => {
@@ -2685,7 +2695,7 @@ fn resolve_bare_identifier_pattern(&mut self, name: Name, span: Span)
                 }
 
                 debug!("(resolve bare identifier pattern) failed to find {}",
-                        token::get_name(name));
+                        name);
                 return BareIdentifierPatternUnresolved;
             }
         }
@@ -3043,13 +3053,13 @@ fn resolve_item_by_name_in_lexical_scope(&mut self,
                         // found a module instead. Modules don't have defs.
                         debug!("(resolving item path by identifier in lexical \
                                  scope) failed to resolve {} after success...",
-                                 token::get_name(name));
+                                 name);
                         return None;
                     }
                     Some(def) => {
                         debug!("(resolving item path in lexical scope) \
                                 resolved `{}` to item",
-                               token::get_name(name));
+                               name);
                         // This lookup is "all public" because it only searched
                         // for one identifier in the current module (couldn't
                         // have passed through reexports or anything like that.
@@ -3062,7 +3072,7 @@ fn resolve_item_by_name_in_lexical_scope(&mut self,
             }
             Failed(err) => {
                 debug!("(resolving item path by identifier in lexical scope) \
-                         failed to resolve {}", token::get_name(name));
+                         failed to resolve {}", name);
 
                 if let Some((span, msg)) = err {
                     self.resolve_error(span, &format!("failed to resolve. {}", msg))
@@ -3472,7 +3482,7 @@ fn record_candidate_traits_for_expr_if_necessary(&mut self, expr: &Expr) {
 
     fn get_traits_containing_item(&mut self, name: Name) -> Vec<DefId> {
         debug!("(getting traits containing item) looking for '{}'",
-               token::get_name(name));
+               name);
 
         fn add_trait_info(found_traits: &mut Vec<DefId>,
                           trait_def_id: DefId,
@@ -3480,7 +3490,7 @@ fn add_trait_info(found_traits: &mut Vec<DefId>,
             debug!("(adding trait info) found trait {}:{} for method '{}'",
                 trait_def_id.krate,
                 trait_def_id.node,
-                token::get_name(name));
+                name);
             found_traits.push(trait_def_id);
         }
 
@@ -3591,7 +3601,7 @@ fn dump_module(&mut self, module_: Rc<Module>) {
         debug!("Children:");
         build_reduced_graph::populate_module_if_necessary(self, &module_);
         for (&name, _) in module_.children.borrow().iter() {
-            debug!("* {}", token::get_name(name));
+            debug!("* {}", name);
         }
 
         debug!("Import resolutions:");
@@ -3615,7 +3625,7 @@ fn dump_module(&mut self, module_: Rc<Module>) {
                 }
             }
 
-            debug!("* {}:{}{}", token::get_name(name), value_repr, type_repr);
+            debug!("* {}:{}{}", name, value_repr, type_repr);
         }
     }
 }

diff --git a/src/librustc_resolve/resolve_imports.rs b/src/librustc_resolve/resolve_imports.rs
index e77e7116b9fea41c86b254c78fa228a3ee35e174..a08d022ffcd7e2b859dabc05b0f7245ed6719a66 100644 (file)
--- a/src/librustc_resolve/resolve_imports.rs
+++ b/src/librustc_resolve/resolve_imports.rs
@@ -394,9 +394,9 @@ fn resolve_single_import(&mut self,
                              -> ResolveResult<()> {
         debug!("(resolving single import) resolving `{}` = `{}::{}` from \
                 `{}` id {}, last private {:?}",
-               token::get_name(target),
+               target,
                module_to_string(&*target_module),
-               token::get_name(source),
+               source,
                module_to_string(module_),
                directive.id,
                lp);
@@ -431,7 +431,7 @@ fn resolve_single_import(&mut self,
                     value_result = BoundResult(target_module.clone(),
                                                (*child_name_bindings).clone());
                     if directive.is_public && !child_name_bindings.is_public(ValueNS) {
-                        let msg = format!("`{}` is private", token::get_name(source));
+                        let msg = format!("`{}` is private", source);
                         span_err!(self.resolver.session, directive.span, E0364, "{}", &msg);
                         pub_err = true;
                     }
@@ -441,7 +441,7 @@ fn resolve_single_import(&mut self,
                     type_result = BoundResult(target_module.clone(),
                                               (*child_name_bindings).clone());
                     if !pub_err && directive.is_public && !child_name_bindings.is_public(TypeNS) {
-                        let msg = format!("`{}` is private", token::get_name(source));
+                        let msg = format!("`{}` is private", source);
                         span_err!(self.resolver.session, directive.span, E0365, "{}", &msg);
                     }
                 }
@@ -655,7 +655,7 @@ fn get_binding(this: &mut Resolver,
 
         if value_result.is_unbound() && type_result.is_unbound() {
             let msg = format!("There is no `{}` in `{}`",
-                              token::get_name(source),
+                              source,
                               module_to_string(&target_module));
             return ResolveResult::Failed(Some((directive.span, msg)));
         }
@@ -736,7 +736,7 @@ fn resolve_glob_import(&mut self,
         for (ident, target_import_resolution) in import_resolutions.iter() {
             debug!("(resolving glob import) writing module resolution \
                     {} into `{}`",
-                   token::get_name(*ident),
+                   *ident,
                    module_to_string(module_));
 
             if !target_import_resolution.is_public {
@@ -842,7 +842,7 @@ fn merge_import_resolution(&mut self,
 
         debug!("(resolving glob import) writing resolution `{}` in `{}` \
                to `{}`",
-               &token::get_name(name),
+               name,
                module_to_string(&*containing_module),
                module_to_string(module_));
 
@@ -861,7 +861,7 @@ fn merge_import_resolution(&mut self,
                         let msg = format!("a {} named `{}` has already been imported \
                                            in this module",
                                           namespace_name,
-                                          &token::get_name(name));
+                                          name);
                         span_err!(self.resolver.session, import_directive.span, E0251, "{}", msg);
                     } else {
                         let target = Target::new(containing_module.clone(),
@@ -894,7 +894,7 @@ fn check_for_conflicting_import(&mut self,
                                     namespace: Namespace) {
         let target = import_resolution.target_for_namespace(namespace);
         debug!("check_for_conflicting_import: {}; target exists: {}",
-               &token::get_name(name),
+               name,
                target.is_some());
 
         match target {
@@ -918,13 +918,13 @@ fn check_for_conflicting_import(&mut self,
                 span_err!(self.resolver.session, import_span, E0252,
                           "a {} named `{}` has already been imported \
                            in this module", ns_word,
-                                  &token::get_name(name));
+                                  name);
                 let use_id = import_resolution.id(namespace);
                 let item = self.resolver.ast_map.expect_item(use_id);
                 // item is syntax::ast::Item;
                 span_note!(self.resolver.session, item.span,
                             "previous import of `{}` here",
-                            token::get_name(name));
+                            name);
             }
             Some(_) | None => {}
         }
@@ -938,7 +938,7 @@ fn check_that_import_is_importable(&mut self,
                                        namespace: Namespace) {
         if !name_bindings.defined_in_namespace_with(namespace, DefModifiers::IMPORTABLE) {
             let msg = format!("`{}` is not directly importable",
-                              token::get_name(name));
+                              name);
             span_err!(self.resolver.session, import_span, E0253, "{}", &msg[..]);
         }
     }
@@ -959,7 +959,7 @@ fn check_for_conflicts_between_imports_and_items(&mut self,
                     let msg = format!("import `{0}` conflicts with imported \
                                        crate in this module \
                                        (maybe you meant `use {0}::*`?)",
-                                      &token::get_name(name));
+                                      name);
                     span_err!(self.resolver.session, import_span, E0254, "{}", &msg[..]);
                 }
                 Some(_) | None => {}
@@ -981,7 +981,7 @@ fn check_for_conflicts_between_imports_and_items(&mut self,
                 if let Some(ref value) = *name_bindings.value_def.borrow() {
                     span_err!(self.resolver.session, import_span, E0255,
                               "import `{}` conflicts with value in this module",
-                              &token::get_name(name));
+                              name);
                     if let Some(span) = value.value_span {
                         self.resolver.session.span_note(span, "conflicting value here");
                     }
@@ -1004,7 +1004,7 @@ fn check_for_conflicts_between_imports_and_items(&mut self,
                     };
                     span_err!(self.resolver.session, import_span, E0256,
                               "import `{}` conflicts with {}",
-                              &token::get_name(name), what);
+                              name, what);
                     if let Some(span) = ty.type_span {
                         self.resolver.session.span_note(span, note);
                     }