---

yaml
---
r: 4989
b: refs/heads/master
c: 03119fe
h: refs/heads/master
i:
  4987: df929e1
v: v3

Author: brson

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 652332f9d44d0c3eb36c220a88ef37f7f875206f
+refs/heads/master: 03119fe269de56e737562a9ee8d1bc47a9013eb4

trunk/src/comp/back/link.rs

@@ -299,12 +299,12 @@ fn build_link_meta(sess: &session::session, c: &ast::crate, output: &str,
         let linkage_metas = attr::find_linkage_metas(c.node.attrs);
         attr::require_unique_names(sess, linkage_metas);
         for meta: @ast::meta_item in linkage_metas {
-            if attr::get_meta_item_name(meta) == "name" {
+            if attr::get_meta_item_name(meta) == ~"name" {
                 alt attr::get_meta_item_value_str(meta) {
                   some(v) { name = some(v); }
                   none. { cmh_items += [meta]; }
                 }
-            } else if attr::get_meta_item_name(meta) == "vers" {
+            } else if attr::get_meta_item_name(meta) == ~"vers" {
                 alt attr::get_meta_item_value_str(meta) {
                   some(v) { vers = some(v); }
                   none. { cmh_items += [meta]; }
@@ -334,11 +334,11 @@ fn build_link_meta(sess: &session::session, c: &ast::crate, output: &str,
             let m = m_;
             alt m.node {
               ast::meta_name_value(key, value) {
-                sha.input_str(len_and_str(istr::from_estr(key)));
+                sha.input_str(len_and_str(key));
                 sha.input_str(len_and_str_lit(value));
               }
               ast::meta_word(name) {
-                sha.input_str(len_and_str(istr::from_estr(name)));
+                sha.input_str(len_and_str(name));
               }
               ast::meta_list(_, _) {
                 // FIXME (#607): Implement this

trunk/src/comp/driver/rustc.rs

@@ -55,11 +55,11 @@ fn default_configuration(sess: session::session, argv0: str, input: str) ->
     let mk = attr::mk_name_value_item_str;
 
     ret [ // Target bindings.
-         mk("target_os", istr::to_estr(std::os::target_os())),
-        mk("target_arch", "x86"),
-         mk("target_libc", libc),
+         mk(~"target_os", istr::to_estr(std::os::target_os())),
+        mk(~"target_arch", "x86"),
+         mk(~"target_libc", libc),
          // Build bindings.
-         mk("build_compiler", argv0), mk("build_input", input)];
+         mk(~"build_compiler", argv0), mk(~"build_input", input)];
 }
 
 fn build_configuration(sess: session::session, argv0: str, input: str) ->
@@ -71,9 +71,9 @@ fn build_configuration(sess: session::session, argv0: str, input: str) ->
     // If the user wants a test runner, then add the test cfg
     let gen_cfg =
         {
-            if sess.get_opts().test && !attr::contains_name(user_cfg, "test")
-               {
-                [attr::mk_word_item("test")]
+            if sess.get_opts().test
+                && !attr::contains_name(user_cfg, ~"test") {
+                [attr::mk_word_item(~"test")]
             } else { [] }
         };
     ret user_cfg + gen_cfg + default_cfg;
@@ -84,7 +84,9 @@ fn parse_cfgspecs(cfgspecs: &[str]) -> ast::crate_cfg {
     // FIXME: It would be nice to use the parser to parse all varieties of
     // meta_item here. At the moment we just support the meta_word variant.
     let words = [];
-    for s: str in cfgspecs { words += [attr::mk_word_item(s)]; }
+    for s: str in cfgspecs {
+        words += [attr::mk_word_item(istr::from_estr(s))];
+    }
     ret words;
 }
 
@@ -655,7 +657,7 @@ mod test {
         let sessopts = build_session_options("whatever", match, "whatever");
         let sess = build_session(sessopts);
         let cfg = build_configuration(sess, "whatever", "whatever");
-        assert (attr::contains_name(cfg, "test"));
+        assert (attr::contains_name(cfg, ~"test"));
     }
 
     // When the user supplies --test and --cfg test, don't implicitly add
@@ -669,7 +671,7 @@ mod test {
         let sessopts = build_session_options("whatever", match, "whatever");
         let sess = build_session(sessopts);
         let cfg = build_configuration(sess, "whatever", "whatever");
-        let test_items = attr::find_meta_items_by_name(cfg, "test");
+        let test_items = attr::find_meta_items_by_name(cfg, ~"test");
         assert (vec::len(test_items) == 1u);
     }
 }

trunk/src/comp/front/attr.rs

@@ -2,6 +2,7 @@
 
 import std::vec;
 import std::str;
+import std::istr;
 import std::map;
 import std::option;
 import syntax::ast;
@@ -32,7 +33,7 @@ export mk_attr;
 // linkage
 fn find_linkage_metas(attrs: &[ast::attribute]) -> [@ast::meta_item] {
     let metas: [@ast::meta_item] = [];
-    for attr: ast::attribute in find_attrs_by_name(attrs, "link") {
+    for attr: ast::attribute in find_attrs_by_name(attrs, ~"link") {
         alt attr.node.value.node {
           ast::meta_list(_, items) { metas += items; }
           _ { log "ignoring link attribute that has incorrect type"; }
@@ -163,11 +164,11 @@ fn sort_meta_items(items: &[@ast::meta_item]) -> [@ast::meta_item] {
     ret v2;
 }
 
-fn remove_meta_items_by_name(items: &[@ast::meta_item], name: str) ->
+fn remove_meta_items_by_name(items: &[@ast::meta_item], name: &istr) ->
    [@ast::meta_item] {
 
     let filter =
-        bind fn (item: &@ast::meta_item, name: str) ->
+        bind fn (item: &@ast::meta_item, name: &istr) ->
                 option::t<@ast::meta_item> {
                  if get_meta_item_name(item) != name {
                      option::some(item)
@@ -178,12 +179,13 @@ fn remove_meta_items_by_name(items: &[@ast::meta_item], name: str) ->
 }
 
 fn require_unique_names(sess: &session::session, metas: &[@ast::meta_item]) {
-    let map = map::mk_hashmap::<str, ()>(str::hash, str::eq);
+    let map = map::new_str_hash();
     for meta: @ast::meta_item in metas {
         let name = get_meta_item_name(meta);
         if map.contains_key(name) {
             sess.span_fatal(meta.span,
-                            #fmt["duplicate meta item `%s`", name]);
+                            #fmt["duplicate meta item `%s`",
+                                 istr::to_estr(name)]);
         }
         map.insert(name, ());
     }

trunk/src/comp/front/config.rs

@@ -94,7 +94,7 @@ fn native_item_in_cfg(cfg: &ast::crate_cfg, item: &@ast::native_item) ->
 fn in_cfg(cfg: &ast::crate_cfg, attrs: &[ast::attribute]) -> bool {
 
     // The "cfg" attributes on the item
-    let item_cfg_attrs = attr::find_attrs_by_name(attrs, "cfg");
+    let item_cfg_attrs = attr::find_attrs_by_name(attrs, ~"cfg");
     let item_has_cfg_attrs = vec::len(item_cfg_attrs) > 0u;
     if !item_has_cfg_attrs { ret true; }
 
@@ -108,7 +108,7 @@ fn in_cfg(cfg: &ast::crate_cfg, attrs: &[ast::attribute]) -> bool {
                [@ast::meta_item] {
                 alt cfg_item.node {
                   ast::meta_list(name, items) {
-                    assert (name == "cfg");
+                    assert (name == ~"cfg");
                     inner_items + items
                   }
                   _ { inner_items }

trunk/src/comp/front/test.rs

@@ -64,7 +64,7 @@ fn fold_mod(_cx: &test_ctxt, m: &ast::_mod, fld: fold::ast_fold) ->
     fn nomain(item: &@ast::item) -> option::t<@ast::item> {
         alt item.node {
           ast::item_fn(f, _) {
-            if item.ident == "main" {
+            if item.ident == ~"main" {
                 option::none
             } else { option::some(item) }
           }
@@ -107,7 +107,7 @@ fn fold_item(cx: &test_ctxt, i: &@ast::item, fld: fold::ast_fold) ->
 
 fn is_test_fn(i: &@ast::item) -> bool {
     let has_test_attr =
-        vec::len(attr::find_attrs_by_name(i.attrs, "test")) > 0u;
+        vec::len(attr::find_attrs_by_name(i.attrs, ~"test")) > 0u;
 
     fn has_test_signature(i: &@ast::item) -> bool {
         alt i.node {
@@ -125,7 +125,7 @@ fn is_test_fn(i: &@ast::item) -> bool {
 }
 
 fn is_ignored(i: &@ast::item) -> bool {
-    attr::contains_name(attr::attr_metas(i.attrs), "ignore")
+    attr::contains_name(attr::attr_metas(i.attrs), ~"ignore")
 }
 
 fn add_test_module(cx: &test_ctxt, m: &ast::_mod) -> ast::_mod {
@@ -160,7 +160,7 @@ fn mk_test_module(cx: &test_ctxt) -> @ast::item {
     let testmod: ast::_mod = {view_items: [], items: [mainfn, testsfn]};
     let item_ = ast::item_mod(testmod);
     let item: ast::item =
-        {ident: "__test",
+        {ident: ~"__test",
          attrs: [],
          id: cx.next_node_id(),
          node: item_,
@@ -198,7 +198,7 @@ fn mk_tests(cx: &test_ctxt) -> @ast::item {
 
     let item_ = ast::item_fn(fn_, []);
     let item: ast::item =
-        {ident: "tests",
+        {ident: ~"tests",
          attrs: [],
          id: cx.next_node_id(),
          node: item_,
@@ -219,7 +219,7 @@ fn empty_fn_ty() -> ast::ty {
 fn mk_test_desc_vec_ty(cx: &test_ctxt) -> @ast::ty {
     let test_desc_ty_path: ast::path =
         nospan({global: false,
-                idents: ["std", "test", "test_desc"],
+                idents: [~"std", ~"test", ~"test_desc"],
                 types: []});
 
     let test_desc_ty: ast::ty =
@@ -256,7 +256,7 @@ fn mk_test_desc_rec(cx: &test_ctxt, test: test) -> @ast::expr {
          span: dummy_sp()};
 
     let name_field: ast::field =
-        nospan({mut: ast::imm, ident: "name", expr: @name_expr});
+        nospan({mut: ast::imm, ident: ~"name", expr: @name_expr});
 
     let fn_path: ast::path = nospan({global: false, idents: path, types: []});
 
@@ -266,7 +266,7 @@ fn mk_test_desc_rec(cx: &test_ctxt, test: test) -> @ast::expr {
          span: dummy_sp()};
 
     let fn_field: ast::field =
-        nospan({mut: ast::imm, ident: "fn", expr: @fn_expr});
+        nospan({mut: ast::imm, ident: ~"fn", expr: @fn_expr});
 
     let ignore_lit: ast::lit = nospan(ast::lit_bool(test.ignore));
 
@@ -276,7 +276,7 @@ fn mk_test_desc_rec(cx: &test_ctxt, test: test) -> @ast::expr {
          span: dummy_sp()};
 
     let ignore_field: ast::field =
-        nospan({mut: ast::imm, ident: "ignore", expr: @ignore_expr});
+        nospan({mut: ast::imm, ident: ~"ignore", expr: @ignore_expr});
 
     let desc_rec_: ast::expr_ =
         ast::expr_rec([name_field, fn_field, ignore_field], option::none);
@@ -291,7 +291,7 @@ fn mk_main(cx: &test_ctxt) -> @ast::item {
     let args_ty: ast::ty = nospan(ast::ty_vec(args_mt));
 
     let args_arg: ast::arg =
-        {mode: ast::val, ty: @args_ty, ident: "args", id: cx.next_node_id()};
+        {mode: ast::val, ty: @args_ty, ident: ~"args", id: cx.next_node_id()};
 
     let ret_ty = nospan(ast::ty_nil);
 
@@ -314,7 +314,7 @@ fn mk_main(cx: &test_ctxt) -> @ast::item {
 
     let item_ = ast::item_fn(fn_, []);
     let item: ast::item =
-        {ident: "main",
+        {ident: ~"main",
          attrs: [],
          id: cx.next_node_id(),
          node: item_,
@@ -326,7 +326,7 @@ fn mk_test_main_call(cx: &test_ctxt) -> @ast::expr {
 
     // Get the args passed to main so we can pass the to test_main
     let args_path: ast::path =
-        nospan({global: false, idents: ["args"], types: []});
+        nospan({global: false, idents: [~"args"], types: []});
 
     let args_path_expr_: ast::expr_ = ast::expr_path(args_path);
 
@@ -335,7 +335,7 @@ fn mk_test_main_call(cx: &test_ctxt) -> @ast::expr {
 
     // Call __test::test to generate the vector of test_descs
     let test_path: ast::path =
-        nospan({global: false, idents: ["tests"], types: []});
+        nospan({global: false, idents: [~"tests"], types: []});
 
     let test_path_expr_: ast::expr_ = ast::expr_path(test_path);
 
@@ -350,7 +350,7 @@ fn mk_test_main_call(cx: &test_ctxt) -> @ast::expr {
     // Call std::test::test_main
     let test_main_path: ast::path =
         nospan({global: false,
-                idents: ["std", "test", "test_main"],
+                idents: [~"std", ~"test", ~"test_main"],
                 types: []});
 
     let test_main_path_expr_: ast::expr_ = ast::expr_path(test_main_path);

trunk/src/comp/metadata/creader.rs

@@ -70,7 +70,7 @@ fn visit_item(e: env, i: &@ast::item) {
         let cstore = e.sess.get_cstore();
         if !cstore::add_used_library(cstore, m.native_name) { ret; }
         for a: ast::attribute in
-            attr::find_attrs_by_name(i.attrs, "link_args") {
+            attr::find_attrs_by_name(i.attrs, ~"link_args") {
             alt attr::get_meta_item_value_str(attr::attr_meta(a)) {
               some(linkarg) { cstore::add_used_link_args(cstore, linkarg); }
               none. {/* fallthrough */ }
@@ -128,15 +128,15 @@ fn find_library_crate(sess: &session::session, ident: &ast::ident,
     // is using the wrong type of meta item
     let crate_name =
         {
-            let name_items = attr::find_meta_items_by_name(metas, "name");
+            let name_items = attr::find_meta_items_by_name(metas, ~"name");
             alt vec::last(name_items) {
               some(i) {
                 alt attr::get_meta_item_value_str(i) {
                   some(n) { n }
-                  _ { ident }
+                  _ { istr::to_estr(ident) }
                 }
               }
-              none. { ident }
+              none. { istr::to_estr(ident) }
             }
         };
 
@@ -219,14 +219,15 @@ fn load_library_crate(sess: &session::session, span: span, ident: &ast::ident,
     alt find_library_crate(sess, ident, metas, library_search_paths) {
       some(t) { ret t; }
       none. {
-        sess.span_fatal(span, #fmt["can't find crate for '%s'", ident]);
+        sess.span_fatal(span, #fmt["can't find crate for '%s'",
+                                   istr::to_estr(ident)]);
       }
     }
 }
 
-fn resolve_crate(e: env, ident: ast::ident, metas: [@ast::meta_item],
+fn resolve_crate(e: env, ident: &ast::ident, metas: [@ast::meta_item],
                  span: span) -> ast::crate_num {
-    if !e.crate_cache.contains_key(istr::from_estr(ident)) {
+    if !e.crate_cache.contains_key(ident) {
         let cinfo =
             load_library_crate(e.sess, span, ident, metas,
                                e.library_search_paths);
@@ -236,19 +237,20 @@ fn resolve_crate(e: env, ident: ast::ident, metas: [@ast::meta_item],
 
         // Claim this crate number and cache it
         let cnum = e.next_crate_num;
-        e.crate_cache.insert(istr::from_estr(ident), cnum);
+        e.crate_cache.insert(ident, cnum);
         e.next_crate_num += 1;
 
         // Now resolve the crates referenced by this crate
         let cnum_map = resolve_crate_deps(e, cdata);
 
-        let cmeta = {name: ident, data: cdata, cnum_map: cnum_map};
+        let cmeta = {name: istr::to_estr(ident),
+                     data: cdata, cnum_map: cnum_map};
 
         let cstore = e.sess.get_cstore();
         cstore::set_crate_data(cstore, cnum, cmeta);
         cstore::add_used_crate_file(cstore, cfilename);
         ret cnum;
-    } else { ret e.crate_cache.get(istr::from_estr(ident)); }
+    } else { ret e.crate_cache.get(ident); }
 }
 
 // Go through the crate metadata and load any crates that it references
@@ -271,7 +273,9 @@ fn resolve_crate_deps(e: env, cdata: &@[u8]) -> cstore::cnum_map {
             // This is a new one so we've got to load it
             // FIXME: Need better error reporting than just a bogus span
             let fake_span = ast_util::dummy_sp();
-            let local_cnum = resolve_crate(e, cname, [], fake_span);
+            let local_cnum = resolve_crate(e,
+                                           istr::from_estr(cname),
+                                           [], fake_span);
             cnum_map.insert(extrn_cnum, local_cnum);
         }
     }

trunk/src/comp/metadata/decoder.rs

@@ -153,7 +153,7 @@ fn resolve_path(path: &[ast::ident], data: @[u8]) -> [ast::def_id] {
     fn eq_item(data: &[u8], s: str) -> bool {
         ret str::eq(str::unsafe_from_bytes(data), s);
     }
-    let s = str::connect(path, "::");
+    let s = istr::to_estr(istr::connect(path, ~"::"));
     let md = ebml::new_doc(data);
     let paths = ebml::get_doc(md, tag_paths);
     let eqer = bind eq_item(_, s);
@@ -302,14 +302,14 @@ fn get_meta_items(md: &ebml::doc) -> [@ast::meta_item] {
     for each meta_item_doc: ebml::doc in
              ebml::tagged_docs(md, tag_meta_item_word) {
         let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
-        let n = str::unsafe_from_bytes(ebml::doc_data(nd));
+        let n = istr::unsafe_from_bytes(ebml::doc_data(nd));
         items += [attr::mk_word_item(n)];
     }
     for each meta_item_doc: ebml::doc in
              ebml::tagged_docs(md, tag_meta_item_name_value) {
         let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
         let vd = ebml::get_doc(meta_item_doc, tag_meta_item_value);
-        let n = str::unsafe_from_bytes(ebml::doc_data(nd));
+        let n = istr::unsafe_from_bytes(ebml::doc_data(nd));
         let v = str::unsafe_from_bytes(ebml::doc_data(vd));
         // FIXME (#611): Should be able to decode meta_name_value variants,
         // but currently they can't be encoded
@@ -318,7 +318,7 @@ fn get_meta_items(md: &ebml::doc) -> [@ast::meta_item] {
     for each meta_item_doc: ebml::doc in
              ebml::tagged_docs(md, tag_meta_item_list) {
         let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
-        let n = str::unsafe_from_bytes(ebml::doc_data(nd));
+        let n = istr::unsafe_from_bytes(ebml::doc_data(nd));
         let subitems = get_meta_items(meta_item_doc);
         items += [attr::mk_list_item(n, subitems)];
     }