librustc: De-`@str` resolve

diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs
index 8e0f4dc9cd8abe4b84dc12bcad2cdb49ebb962ab..261544adfd1f9d8efa4e8b6c219b168beec57519 100644 (file)
--- a/src/librustc/metadata/encoder.rs
+++ b/src/librustc/metadata/encoder.rs
@@ -490,7 +490,7 @@ fn encode_reexported_static_methods(ecx: &EncodeContext,
                                     exp: &middle::resolve::Export2) {
     match ecx.tcx.items.find(exp.def_id.node) {
         Some(ast_map::NodeItem(item, path)) => {
-            let original_name = ecx.tcx.sess.str_of(item.ident);
+            let original_name = token::get_ident(item.ident.name);
 
             //
             // We don't need to reexport static methods on items
@@ -502,7 +502,7 @@ fn encode_reexported_static_methods(ecx: &EncodeContext,
             // encoded metadata for static methods relative to Bar,
             // but not yet for Foo.
             //
-            if mod_path != *path || exp.name != original_name {
+            if mod_path != *path || original_name.get() != exp.name {
                 if !encode_reexported_static_base_methods(ecx, ebml_w, exp) {
                     if encode_reexported_static_trait_methods(ecx, ebml_w, exp) {
                         debug!("(encode reexported static methods) {} \

diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs
index c28306a7aaca38031c7e110ca875f7282fccfec1..26e04110a7b49a4f11aecb5bacf9a6830da3b497 100644 (file)
--- a/src/librustc/middle/resolve.rs
+++ b/src/librustc/middle/resolve.rs
@@ -20,9 +20,8 @@
 use syntax::ast;
 use syntax::ast_util::{def_id_of_def, local_def, mtwt_resolve};
 use syntax::ast_util::{path_to_ident, walk_pat, trait_method_to_ty_method};
+use syntax::parse::token::{IdentInterner, special_idents};
 use syntax::parse::token;
-use syntax::parse::token::{IdentInterner, interner_get};
-use syntax::parse::token::special_idents;
 use syntax::print::pprust::path_to_str;
 use syntax::codemap::{Span, DUMMY_SP, Pos};
 use syntax::opt_vec::OptVec;
@@ -53,7 +52,7 @@ struct binding_info {
 pub type ExportMap2 = @RefCell<HashMap<NodeId, ~[Export2]>>;
 
 pub struct Export2 {
-    name: @str,        // The name of the target.
+    name: ~str,        // The name of the target.
     def_id: DefId,     // The definition of the target.
 }
 
@@ -2114,24 +2113,26 @@ fn path_idents_to_str(&mut self, path: &Path) -> ~str {
     }
 
     fn import_directive_subclass_to_str(&mut self,
-                                            subclass: ImportDirectiveSubclass)
-                                            -> @str {
+                                        subclass: ImportDirectiveSubclass)
+                                        -> ~str {
         match subclass {
-            SingleImport(_target, source) => self.session.str_of(source),
-            GlobImport => @"*"
+            SingleImport(_target, source) => {
+                self.session.str_of(source).to_str()
+            }
+            GlobImport => ~"*"
         }
     }
 
     fn import_path_to_str(&mut self,
-                              idents: &[Ident],
-                              subclass: ImportDirectiveSubclass)
-                              -> @str {
+                          idents: &[Ident],
+                          subclass: ImportDirectiveSubclass)
+                          -> ~str {
         if idents.is_empty() {
             self.import_directive_subclass_to_str(subclass)
         } else {
             (format!("{}::{}",
-                  self.idents_to_str(idents),
-                  self.import_directive_subclass_to_str(subclass))).to_managed()
+                     self.idents_to_str(idents),
+                     self.import_directive_subclass_to_str(subclass)))
         }
     }
 
@@ -2584,7 +2585,7 @@ fn resolve_glob_import(&mut self,
 
             debug!("(resolving glob import) writing resolution `{}` in `{}` \
                     to `{}`",
-                   interner_get(name),
+                   token::get_ident(name).get().to_str(),
                    self.module_to_str(containing_module),
                    self.module_to_str(module_));
 
@@ -3354,10 +3355,10 @@ fn add_exports_of_namebindings(&mut self,
         match namebindings.def_for_namespace(ns) {
             Some(d) => {
                 debug!("(computing exports) YES: export '{}' => {:?}",
-                       interner_get(name),
+                       token::get_ident(name).get().to_str(),
                        def_id_of_def(d));
                 exports2.push(Export2 {
-                    name: interner_get(name),
+                    name: token::get_ident(name).get().to_str(),
                     def_id: def_id_of_def(d)
                 });
             }
@@ -3380,7 +3381,7 @@ fn add_exports_for_module(&mut self,
                 match importresolution.target_for_namespace(ns) {
                     Some(target) => {
                         debug!("(computing exports) maybe export '{}'",
-                               interner_get(*name));
+                               token::get_ident(*name).get().to_str());
                         self.add_exports_of_namebindings(exports2,
                                                          *name,
                                                          target.bindings,
@@ -4155,19 +4156,23 @@ fn check_consistent_bindings(&mut self, arm: &Arm) {
             for (&key, &binding_0) in map_0.iter() {
                 match map_i.find(&key) {
                   None => {
+                    let string = token::get_ident(key);
                     self.resolve_error(
                         p.span,
                         format!("variable `{}` from pattern \\#1 is \
                                   not bound in pattern \\#{}",
-                             interner_get(key), i + 1));
+                                string.get(),
+                                i + 1));
                   }
                   Some(binding_i) => {
                     if binding_0.binding_mode != binding_i.binding_mode {
+                        let string = token::get_ident(key);
                         self.resolve_error(
                             binding_i.span,
                             format!("variable `{}` is bound with different \
                                       mode in pattern \\#{} than in pattern \\#1",
-                                 interner_get(key), i + 1));
+                                    string.get(),
+                                    i + 1));
                     }
                   }
                 }
@@ -4175,11 +4180,13 @@ fn check_consistent_bindings(&mut self, arm: &Arm) {
 
             for (&key, &binding) in map_i.iter() {
                 if !map_0.contains_key(&key) {
+                    let string = token::get_ident(key);
                     self.resolve_error(
                         binding.span,
                         format!("variable `{}` from pattern \\#{} is \
                                   not bound in pattern \\#1",
-                             interner_get(key), i + 1));
+                                string.get(),
+                                i + 1));
                 }
             }
         }
@@ -4371,9 +4378,10 @@ fn resolve_pattern(&mut self,
                     match self.resolve_bare_identifier_pattern(ident) {
                         FoundStructOrEnumVariant(def, lp)
                                 if mode == RefutableMode => {
+                            let string = token::get_ident(renamed);
                             debug!("(resolving pattern) resolving `{}` to \
                                     struct or enum variant",
-                                   interner_get(renamed));
+                                   string.get());
 
                             self.enforce_default_binding_mode(
                                 pattern,
@@ -4382,17 +4390,19 @@ struct or enum variant",
                             self.record_def(pattern.id, (def, lp));
                         }
                         FoundStructOrEnumVariant(..) => {
+                            let string = token::get_ident(renamed);
                             self.resolve_error(pattern.span,
                                                   format!("declaration of `{}` \
                                                         shadows an enum \
                                                         variant or unit-like \
                                                         struct in scope",
-                                                       interner_get(renamed)));
+                                                          string.get()));
                         }
                         FoundConst(def, lp) if mode == RefutableMode => {
+                            let string = token::get_ident(renamed);
                             debug!("(resolving pattern) resolving `{}` to \
                                     constant",
-                                   interner_get(renamed));
+                                   string.get());
 
                             self.enforce_default_binding_mode(
                                 pattern,
@@ -4406,8 +4416,9 @@ struct in scope",
                                                    allowed here");
                         }
                         BareIdentifierPatternUnresolved => {
+                            let string = token::get_ident(renamed);
                             debug!("(resolving pattern) binding `{}`",
-                                   interner_get(renamed));
+                                   string.get());
 
                             let def = match mode {
                                 RefutableMode => {
@@ -5009,10 +5020,10 @@ fn resolve_error(&mut self, span: Span, s: &str) {
     }
 
     fn find_best_match_for_name(&mut self, name: &str, max_distance: uint)
-                                -> Option<@str> {
+                                -> Option<~str> {
         let this = &mut *self;
 
-        let mut maybes: ~[@str] = ~[];
+        let mut maybes: ~[~str] = ~[];
         let mut values: ~[uint] = ~[];
 
         let mut j = {
@@ -5024,14 +5035,15 @@ fn find_best_match_for_name(&mut self, name: &str, max_distance: uint)
             let value_ribs = this.value_ribs.borrow();
             let bindings = value_ribs.get()[j].bindings.borrow();
             for (&k, _) in bindings.get().iter() {
-                maybes.push(interner_get(k));
+                let string = token::get_ident(k);
+                maybes.push(string.get().to_str());
                 values.push(uint::MAX);
             }
         }
 
         let mut smallest = 0;
-        for (i, &other) in maybes.iter().enumerate() {
-            values[i] = name.lev_distance(other);
+        for (i, other) in maybes.iter().enumerate() {
+            values[i] = name.lev_distance(*other);
 
             if values[i] <= values[smallest] {
                 smallest = i;
@@ -5190,7 +5202,9 @@ fn resolve_expr(&mut self, expr: &Expr) {
                         self.resolve_error(expr.span,
                                               format!("use of undeclared label \
                                                    `{}`",
-                                                   interner_get(label))),
+                                                   token::get_ident(label)
+                                                    .get()
+                                                    .to_str())),
                     Some(DlDef(def @ DefLabel(_))) => {
                         // FIXME: is AllPublic correct?
                         self.record_def(expr.id, (def, AllPublic))
@@ -5510,7 +5524,7 @@ fn dump_module(&mut self, module_: @Module) {
         self.populate_module_if_necessary(module_);
         let children = module_.children.borrow();
         for (&name, _) in children.get().iter() {
-            debug!("* {}", interner_get(name));
+            debug!("* {}", token::get_ident(name).get().to_str());
         }
 
         debug!("Import resolutions:");
@@ -5534,7 +5548,7 @@ fn dump_module(&mut self, module_: @Module) {
                 }
             }
 
-            debug!("* {}:{}{}", interner_get(*name),
+            debug!("* {}:{}{}", token::get_ident(*name).get().to_str(),
                    value_repr, type_repr);
         }
     }