rustc: Move the interner to a new module intended to be used for general data structures

Author: pcwalton

src/comp/front/lexer.rs

@@ -10,7 +10,7 @@ import std::option::none;
 import driver::session::session;
 import util::common;
 import util::common::new_str_hash;
-import util::interner;
+import util::data::interner;
 
 state type reader = state obj {
     fn is_eof() -> bool;
@@ -800,7 +800,7 @@ fn read_block_comment(&reader rdr) -> cmnt {
 
 fn gather_comments(session sess, str path) -> vec[cmnt] {
     auto srdr = io::file_reader(path);
-    auto itr = @interner::mk_interner[str](str::hash, str::eq);
+    auto itr = @interner::mk[str](str::hash, str::eq);
     auto rdr = new_reader(sess, srdr, codemap::new_filemap(path, 0u), itr);
     let vec[cmnt] comments = [];
     while (!rdr.is_eof()) {

src/comp/front/parser.rs

@@ -11,7 +11,7 @@ import util::common;
 import util::common::filename;
 import util::common::span;
 import util::common::new_str_hash;
-import util::interner;
+import util::data::interner;
 
 tag restriction {
     UNRESTRICTED;
@@ -165,7 +165,7 @@ fn new_parser(session::session sess,
     auto srdr = io::file_reader(path);
     auto filemap = codemap::new_filemap(path, pos);
     vec::push[codemap::filemap](sess.get_codemap().files, filemap);
-    auto itr = @interner::mk_interner[str](str::hash, str::eq);
+    auto itr = @interner::mk[str](str::hash, str::eq);
     auto rdr = lexer::new_reader(sess, srdr, filemap, itr);
     // Make sure npos points at first actual token:
     lexer::consume_any_whitespace(rdr);

src/comp/front/token.rs

@@ -1,7 +1,7 @@
 import util::common::ty_mach;
 import util::common::ty_mach_to_str;
 import util::common::new_str_hash;
-import util::interner;
+import util::data::interner;
 import std::int;
 import std::uint;
 import std::str;

src/comp/middle/ty.rs

@@ -34,7 +34,7 @@ import util::common::new_def_hash;
 import util::common::span;
 import middle::tstate::ann::ts_ann;
 
-import util::interner;
+import util::data::interner;
 
 // Data types
 
@@ -232,7 +232,7 @@ fn mk_ctxt(session::session s, resolve::def_map dm) -> ctxt {
         common::new_def_hash[ty::ty_param_count_and_ty]();
 
     auto items = common::new_def_hash[any_item]();
-    auto ts = @interner::mk_interner[raw_t](hash_raw_ty, eq_raw_ty);
+    auto ts = @interner::mk[raw_t](hash_raw_ty, eq_raw_ty);
 
     auto cx =
         rec(ts = ts,

src/comp/rustc.rc

@@ -62,7 +62,7 @@ mod driver {
 
 mod util {
     mod common;
-    mod interner;
+    mod data;
 }
 
 auth front::creader::load_crate = unsafe;

src/comp/util/data.rs

@@ -0,0 +1,44 @@
+// An "interner" is a data structure that associates values with uint tags and
+// allows bidirectional lookup; i.e. given a value, one can easily find the
+// type, and vice versa.
+
+import std::vec;
+import std::map;
+import std::map::hashmap;
+import std::map::hashfn;
+import std::map::eqfn;
+import std::option;
+import std::option::none;
+import std::option::some;
+
+mod interner {
+    type interner[T] = rec(
+        hashmap[T,uint] map,
+        mutable vec[T] vect,
+        hashfn[T] hasher,
+        eqfn[T] eqer
+    );
+
+    fn mk[T](hashfn[T] hasher, eqfn[T] eqer) -> interner[T] {
+        auto m = map::mk_hashmap[T,uint](hasher, eqer);
+        let vec[T] vect = [];
+        ret rec(map=m, mutable vect=vect, hasher=hasher, eqer=eqer);
+    }
+
+    fn intern[T](&interner[T] itr, &T val) -> uint {
+        alt (itr.map.find(val)) {
+            case (some[uint](?idx)) { ret idx; }
+            case (none[uint]) {
+                auto new_idx = vec::len[T](itr.vect);
+                itr.map.insert(val, new_idx);
+                itr.vect += [val];
+                ret new_idx;
+            }
+        }
+    }
+
+    fn get[T](&interner[T] itr, uint idx) -> T {
+        ret itr.vect.(idx);
+    }
+}
+