---

yaml
---
r: 13396
b: refs/heads/master
c: 21087bf
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 8fea5260c2f62fe24e9d86b461d5580d3f217952
+refs/heads/master: 21087bf1a5120739dc865e18d4500a16a8a16648
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/src/libsyntax/parse.rs

@@ -134,7 +134,7 @@ fn new_parser_from_source_str(sess: parse_sess, cfg: ast::crate_cfg,
     let filemap = codemap::new_filemap_w_substr
         (name, ss, source, sess.chpos, sess.byte_pos);
     sess.cm.files.push(filemap);
-    let itr = @interner::mk(str::hash, str::eq);
+    let itr = @interner::mk::<@str>({|x|str::hash(*x)}, {|x,y|str::eq(*x, *y)});
     let rdr = lexer::new_reader(sess.span_diagnostic,
                                 filemap, itr);
     ret parser(sess, cfg, rdr, ftype);
@@ -152,7 +152,7 @@ fn new_parser_from_file(sess: parse_sess, cfg: ast::crate_cfg, +path: str,
     let src = @copy result::unwrap(res);
     let filemap = codemap::new_filemap(path, src, sess.chpos, sess.byte_pos);
     sess.cm.files.push(filemap);
-    let itr = @interner::mk(str::hash, str::eq);
+       let itr = @interner::mk::<@str>({|x|str::hash(*x)}, {|x,y|str::eq(*x, *y)});
     let rdr = lexer::new_reader(sess.span_diagnostic, filemap, itr);
     ret parser(sess, cfg, rdr, ftype);
 }

trunk/src/libsyntax/parse/comments.rs

@@ -169,7 +169,10 @@ fn gather_comments_and_literals(span_diagnostic: diagnostic::span_handler,
                                 srdr: io::reader) ->
    {cmnts: [cmnt], lits: [lit]} {
     let src = @str::from_bytes(srdr.read_whole_stream());
-    let itr = @interner::mk::<str>(str::hash, str::eq);
+    let itr = @interner::mk::<@str>(
+        {|x|str::hash(*x)},
+        {|x,y|str::eq(*x, *y)}
+    );
     let rdr = new_reader(span_diagnostic,
                          codemap::new_filemap(path, src, 0u, 0u), itr);
     let mut comments: [cmnt] = [];

trunk/src/libsyntax/parse/lexer.rs

@@ -12,7 +12,7 @@ type reader = @{
     mut curr: char,
     mut chpos: uint,
     filemap: codemap::filemap,
-    interner: @interner::interner<str>
+    interner: @interner::interner<@str>
 };
 
 impl reader for reader {
@@ -55,7 +55,7 @@ impl reader for reader {
 
 fn new_reader(span_diagnostic: diagnostic::span_handler,
               filemap: codemap::filemap,
-              itr: @interner::interner<str>) -> reader {
+              itr: @interner::interner<@str>) -> reader {
     let r = @{span_diagnostic: span_diagnostic, src: filemap.src,
               mut col: 0u, mut pos: 0u, mut curr: -1 as char,
               mut chpos: filemap.start_pos.ch,
@@ -260,12 +260,12 @@ fn scan_number(c: char, rdr: reader) -> token::token {
         if c == '3' && n == '2' {
             rdr.bump();
             rdr.bump();
-            ret token::LIT_FLOAT(intern(*rdr.interner, num_str),
+            ret token::LIT_FLOAT(intern(*rdr.interner, @num_str),
                                  ast::ty_f32);
         } else if c == '6' && n == '4' {
             rdr.bump();
             rdr.bump();
-            ret token::LIT_FLOAT(intern(*rdr.interner, num_str),
+            ret token::LIT_FLOAT(intern(*rdr.interner, @num_str),
                                  ast::ty_f64);
             /* FIXME: if this is out of range for either a 32-bit or
             64-bit float, it won't be noticed till the back-end (Issue #2252)
@@ -275,7 +275,7 @@ fn scan_number(c: char, rdr: reader) -> token::token {
         }
     }
     if is_float {
-        ret token::LIT_FLOAT(interner::intern(*rdr.interner, num_str),
+        ret token::LIT_FLOAT(intern(*rdr.interner, @num_str),
                              ast::ty_f);
     } else {
         if str::len(num_str) == 0u {
@@ -329,8 +329,8 @@ fn next_token_inner(rdr: reader) -> token::token {
         let is_mod_name = c == ':' && rdr.next() == ':';
 
         // FIXME: perform NFKC normalization here. (Issue #2253)
-        ret token::IDENT(interner::intern::<str>(*rdr.interner,
-                                                 accum_str), is_mod_name);
+        ret token::IDENT(interner::intern(*rdr.interner,
+                                          @accum_str), is_mod_name);
     }
     if is_dec_digit(c) {
         ret scan_number(c, rdr);
@@ -494,8 +494,8 @@ fn next_token_inner(rdr: reader) -> token::token {
             }
         }
         rdr.bump();
-        ret token::LIT_STR(interner::intern::<str>(*rdr.interner,
-                                                   accum_str));
+        ret token::LIT_STR(interner::intern(*rdr.interner,
+                                            @accum_str));
       }
       '-' {
         if rdr.next() == '>' {

trunk/src/libsyntax/parse/parser.rs

@@ -10,7 +10,7 @@ import lexer::reader;
 import prec::{as_prec, token_to_binop};
 import attr::parser_attr;
 import common::{seq_sep, seq_sep_opt, seq_sep_none, token_to_str};
-import common::{parser_common};
+import common::*;//{parser_common};
 import dvec::{dvec, extensions};
 
 export file_type;
@@ -151,7 +151,7 @@ class parser {
         self.sess.span_diagnostic.span_warn(copy self.span, m)
     }
     fn get_str(i: token::str_num) -> str {
-        interner::get(*self.reader.interner, i)
+        *interner::get(*self.reader.interner, i)
     }
     fn get_id() -> node_id { next_node_id(self.sess) }
 

trunk/src/libsyntax/parse/token.rs

@@ -83,7 +83,7 @@ fn binop_to_str(o: binop) -> str {
     }
 }
 
-fn to_str(in: interner<str>, t: token) -> str {
+fn to_str(in: interner<@str>, t: token) -> str {
     alt t {
       EQ { ret "="; }
       LT { ret "<"; }
@@ -133,17 +133,17 @@ fn to_str(in: interner<str>, t: token) -> str {
         ret uint::to_str(u as uint, 10u) + ast_util::uint_ty_to_str(t);
       }
       LIT_FLOAT(s, t) {
-        ret interner::get::<str>(in, s) +
+        ret *interner::get(in, s) +
             ast_util::float_ty_to_str(t);
       }
       LIT_STR(s) {
         ret "\""
-            + str::escape_default(interner::get::<str>(in, s))
+            + str::escape_default(*interner::get(in, s))
             + "\"";
       }
       /* Name components */
       IDENT(s, _) {
-        ret interner::get::<str>(in, s);
+        ret *interner::get(in, s);
       }
       UNDERSCORE { ret "_"; }
       EOF { ret "<eof>"; }