intern identifiers

Author: paulstansifer

src/cargo/cargo.rs

@@ -225,7 +225,7 @@ fn load_link(mis: ~[@ast::meta_item]) -> (option<~str>,
     for mis.each |a| {
         match a.node {
             ast::meta_name_value(v, {node: ast::lit_str(s), span: _}) => {
-                match *v {
+                match v {
                     ~"name" => name = some(*s),
                     ~"vers" => vers = some(*s),
                     ~"uuid" => uuid = some(*s),
@@ -252,15 +252,15 @@ fn load_crate(filename: ~str) -> option<crate> {
     for c.node.attrs.each |a| {
         match a.node.value.node {
             ast::meta_name_value(v, {node: ast::lit_str(s), span: _}) => {
-                match *v {
-                    ~"desc" => desc = some(*v),
-                    ~"sigs" => sigs = some(*v),
-                    ~"crate_type" => crate_type = some(*v),
+                match v {
+                    ~"desc" => desc = some(v),
+                    ~"sigs" => sigs = some(v),
+                    ~"crate_type" => crate_type = some(v),
                     _ => { }
                 }
             }
             ast::meta_list(v, mis) => {
-                if *v == ~"link" {
+                if v == ~"link" {
                     let (n, v, u) = load_link(mis);
                     name = n;
                     vers = v;
@@ -278,13 +278,15 @@ fn load_crate(filename: ~str) -> option<crate> {
         mut deps: ~[~str]
     };
 
-    fn goto_view_item(e: env, i: @ast::view_item) {
+    fn goto_view_item(ps: syntax::parse::parse_sess, e: env,
+                      i: @ast::view_item) {
         match i.node {
             ast::view_item_use(ident, metas, id) => {
                 let name_items =
                     attr::find_meta_items_by_name(metas, ~"name");
                 let m = if name_items.is_empty() {
-                    metas + ~[attr::mk_name_value_item_str(@~"name", *ident)]
+                    metas + ~[attr::mk_name_value_item_str(
+                        ~"name", *ps.interner.get(ident))]
                 } else {
                     metas
                 };
@@ -297,9 +299,9 @@ fn load_crate(filename: ~str) -> option<crate> {
                         some(value) => {
                             let name = attr::get_meta_item_name(item);
 
-                            match *name {
-                                ~"vers" => attr_vers = *value,
-                                ~"from" => attr_from = *value,
+                            match name {
+                                ~"vers" => attr_vers = value,
+                                ~"from" => attr_from = value,
                                 _ => ()
                             }
                         }
@@ -311,11 +313,11 @@ fn load_crate(filename: ~str) -> option<crate> {
                     attr_from
                 } else {
                     if !str::is_empty(attr_vers) {
-                        *attr_name + ~"@" + attr_vers
-                    } else { *attr_name }
+                        ps.interner.get(attr_name) + ~"@" + attr_vers
+                    } else { *ps.interner.get(attr_name) }
                 };
 
-                match *attr_name {
+                match *ps.interner.get(attr_name) {
                     ~"std" | ~"core" => (),
                     _ => vec::push(e.deps, query)
                 }
@@ -330,7 +332,7 @@ fn load_crate(filename: ~str) -> option<crate> {
         mut deps: ~[]
     };
     let v = visit::mk_simple_visitor(@{
-        visit_view_item: |a| goto_view_item(e, a),
+        visit_view_item: |a| goto_view_item(sess, e, a),
         visit_item: |a| goto_item(e, a),
         with *visit::default_simple_visitor()
     });

src/fuzzer/fuzzer.rs

@@ -238,29 +238,31 @@ fn check_variants_T<T: copy>(
   filename: ~str,
   thing_label: ~str,
   things: ~[T],
-  stringifier: fn@(@T) -> ~str,
+  stringifier: fn@(@T, syntax::parse::token::ident_interner) -> ~str,
   replacer: fn@(ast::crate, uint, T, test_mode) -> ast::crate,
   cx: context
   ) {
     error!{"%s contains %u %s objects", filename,
            vec::len(things), thing_label};
 
+    // Assuming we're not generating any token_trees
+    let intr = syntax::parse::token::mk_fake_ident_interner();
+
     let L = vec::len(things);
 
     if L < 100u {
         do under(uint::min(L, 20u)) |i| {
             log(error, ~"Replacing... #" + uint::str(i));
             do under(uint::min(L, 30u)) |j| {
-                log(error, ~"With... " + stringifier(@things[j]));
+                log(error, ~"With... " + stringifier(@things[j], intr));
                 let crate2 = @replacer(crate, i, things[j], cx.mode);
                 // It would be best to test the *crate* for stability, but
                 // testing the string for stability is easier and ok for now.
                 let handler = diagnostic::mk_handler(none);
                 let str3 =
                     @as_str(|a|pprust::print_crate(
                         codemap,
-                        // Assuming we're not generating any token_trees
-                        syntax::parse::token::mk_ident_interner(),
+                        intr,
                         diagnostic::mk_span_handler(handler, codemap),
                         crate2,
                         filename,
@@ -422,7 +424,7 @@ fn parse_and_print(code: @~str) -> ~str {
                pprust::print_crate(
                    sess.cm,
                    // Assuming there are no token_trees
-                   syntax::parse::token::mk_ident_interner(),
+                   syntax::parse::token::mk_fake_ident_interner(),
                    sess.span_diagnostic,
                    crate,
                    filename,
@@ -570,7 +572,7 @@ fn check_variants(files: ~[~str], cx: context) {
                    as_str(|a| pprust::print_crate(
                        sess.cm,
                        // Assuming no token_trees
-                       syntax::parse::token::mk_ident_interner(),
+                       syntax::parse::token::mk_fake_ident_interner(),
                        sess.span_diagnostic,
                        crate,
                        file,