---

yaml
---
r: 13450
b: refs/heads/master
c: ce750a7
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: bdd20000665a35e14b4ec2c54f893fc80fe451ef
+refs/heads/master: ce750a7dbcd2dc68db6de89956b1de3ecf9f2d0a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/src/cargo/cargo.rs

@@ -224,10 +224,10 @@ fn load_link(mis: [@ast::meta_item]) -> (option<str>,
     for mis.each {|a|
         alt a.node {
             ast::meta_name_value(v, {node: ast::lit_str(s), span: _}) {
-                alt v {
-                    "name" { name = some(s); }
-                    "vers" { vers = some(s); }
-                    "uuid" { uuid = some(s); }
+                alt *v {
+                    "name" { name = some(*s); }
+                    "vers" { vers = some(*s); }
+                    "uuid" { uuid = some(*s); }
                     _ { }
                 }
             }
@@ -259,15 +259,15 @@ fn load_crate(filename: str) -> option<crate> {
     for c.node.attrs.each {|a|
         alt a.node.value.node {
             ast::meta_name_value(v, {node: ast::lit_str(s), span: _}) {
-                alt v {
-                    "desc" { desc = some(v); }
-                    "sigs" { sigs = some(v); }
-                    "crate_type" { crate_type = some(v); }
+                alt *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;
@@ -290,7 +290,7 @@ fn load_crate(filename: str) -> option<crate> {
             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", *ident)]
                 } else {
                     metas
                 };
@@ -303,9 +303,9 @@ fn load_crate(filename: str) -> option<crate> {
                         some(value) {
                             let name = attr::get_meta_item_name(item);
 
-                            alt name {
-                                "vers" { attr_vers = value; }
-                                "from" { attr_from = value; }
+                            alt *name {
+                                "vers" { attr_vers = *value; }
+                                "from" { attr_from = *value; }
                                 _ {}
                             }
                         }
@@ -317,11 +317,11 @@ fn load_crate(filename: str) -> option<crate> {
                     attr_from
                 } else {
                     if !str::is_empty(attr_vers) {
-                        attr_name + "@" + attr_vers
-                    } else { attr_name }
+                        *attr_name + "@" + attr_vers
+                    } else { *attr_name }
                 };
 
-                alt attr_name {
+                alt *attr_name {
                     "std" | "core" { }
                     _ { e.deps += [query]; }
                 }

trunk/src/fuzzer/fuzzer.rs

@@ -45,7 +45,7 @@ fn common_exprs() -> [ast::expr] {
      dse(ast::expr_cont),
      dse(ast::expr_fail(option::none)),
      dse(ast::expr_fail(option::some(
-         @dse(ast::expr_lit(@dsl(ast::lit_str("boo"))))))),
+         @dse(ast::expr_lit(@dsl(ast::lit_str(@"boo"))))))),
      dse(ast::expr_ret(option::none)),
      dse(ast::expr_lit(@dsl(ast::lit_nil))),
      dse(ast::expr_lit(@dsl(ast::lit_bool(false)))),

trunk/src/libstd/map.rs

@@ -2,6 +2,7 @@
 
 import chained::hashmap;
 export hashmap, hashfn, eqfn, set, map, chained, hashmap, str_hash;
+export box_str_hash;
 export bytes_hash, int_hash, uint_hash, set_add;
 export hash_from_vec, hash_from_strs, hash_from_bytes;
 export hash_from_ints, hash_from_uints;
@@ -292,6 +293,11 @@ fn str_hash<V: copy>() -> hashmap<str, V> {
     ret hashmap(str::hash, str::eq);
 }
 
+#[doc = "Construct a hashmap for boxed string keys"]
+fn box_str_hash<V: copy>() -> hashmap<@str, V> {
+    ret hashmap({|x: @str|str::hash(*x)}, {|x,y|str::eq(*x,*y)});
+}
+
 #[doc = "Construct a hashmap for byte string keys"]
 fn bytes_hash<V: copy>() -> hashmap<[u8], V> {
     ret hashmap(vec::u8::hash, vec::u8::eq);

trunk/src/libsyntax/ast.rs

@@ -30,7 +30,7 @@ fn deserialize_span<D>(_d: D) -> span {
 type spanned<T> = {node: T, span: span};
 
 #[auto_serialize]
-type ident = str;
+type ident = @str;
 
 // Functions may or may not have names.
 #[auto_serialize]
@@ -399,11 +399,11 @@ type lit = spanned<lit_>;
 
 #[auto_serialize]
 enum lit_ {
-    lit_str(str),
+    lit_str(@str),
     lit_int(i64, int_ty),
     lit_uint(u64, uint_ty),
     lit_int_unsuffixed(i64, int_ty),
-    lit_float(str, float_ty),
+    lit_float(@str, float_ty),
     lit_nil,
     lit_bool(bool),
 }

trunk/src/libsyntax/ast_map.rs

@@ -6,24 +6,24 @@ import ast_util::path_to_ident;
 import ast_util::inlined_item_methods;
 import diagnostic::span_handler;
 
-enum path_elt { path_mod(str), path_name(str) }
+enum path_elt { path_mod(ident), path_name(ident) }
 type path = [path_elt];
 
 fn path_to_str_with_sep(p: path, sep: str) -> str {
     let strs = vec::map(p) {|e|
         alt e {
-          path_mod(s) { /* FIXME: bad */ copy s }
-          path_name(s) { /* FIXME: bad */ copy s }
+          path_mod(s) { /* FIXME: bad */ copy *s }
+          path_name(s) { /* FIXME: bad */ copy *s }
         }
     };
     str::connect(strs, sep)
 }
 
 fn path_ident_to_str(p: path, i: ident) -> str {
     if vec::is_empty(p) {
-        /* FIXME: bad */ copy i
+        /* FIXME: bad */ copy *i
     } else {
-        #fmt["%s::%s", path_to_str(p), i]
+        #fmt["%s::%s", path_to_str(p), *i]
     }
 }
 
@@ -59,7 +59,7 @@ type ctx = {map: map, mut path: path,
             mut local_id: uint, diag: span_handler};
 type vt = visit::vt<ctx>;
 
-fn extend(cx: ctx, +elt: str) -> @path {
+fn extend(cx: ctx, +elt: ident) -> @path {
     @(cx.path + [path_name(elt)])
 }
 
@@ -192,7 +192,7 @@ fn map_item(i: @item, cx: ctx, v: vt) {
       item_impl(_, _, _, _, ms) {
         let impl_did = ast_util::local_def(i.id);
         for ms.each {|m|
-            map_method(impl_did, extend(cx, /* FIXME: bad */ copy i.ident), m,
+            map_method(impl_did, extend(cx, i.ident), m,
                        cx);
         }
       }
@@ -208,7 +208,7 @@ fn map_item(i: @item, cx: ctx, v: vt) {
         for vs.each {|v|
             cx.map.insert(v.node.id, node_variant(
                 /* FIXME: bad */ copy v, i,
-                extend(cx, /* FIXME: bad */ copy i.ident)));
+                extend(cx, i.ident)));
         }
       }
       item_native_mod(nm) {
@@ -229,17 +229,17 @@ fn map_item(i: @item, cx: ctx, v: vt) {
           vec::iter(ifces) {|p| cx.map.insert(p.id,
                                   node_item(i, item_path)); };
           let d_id = ast_util::local_def(i.id);
-          let p = extend(cx, /* FIXME: bad */ copy i.ident);
+          let p = extend(cx, i.ident);
            // only need to handle methods
           vec::iter(ms) {|m| map_method(d_id, p, m, cx); }
       }
       _ { }
     }
     alt i.node {
       item_mod(_) | item_native_mod(_) {
-        cx.path += [path_mod(/* FIXME: bad */ copy i.ident)];
+        cx.path += [path_mod(i.ident)];
       }
-      _ { cx.path += [path_name(/* FIXME: bad */ copy i.ident)]; }
+      _ { cx.path += [path_name(i.ident)]; }
     }
     visit::visit_item(i, cx, v);
     vec::pop(cx.path);
@@ -281,11 +281,11 @@ fn node_id_to_str(map: map, id: node_id) -> str {
       }
       some(node_method(m, impl_did, path)) {
         #fmt["method %s in %s (id=%?)",
-             m.ident, path_to_str(*path), id]
+             *m.ident, path_to_str(*path), id]
       }
       some(node_variant(variant, def_id, path)) {
         #fmt["variant %s in %s (id=%?)",
-             variant.node.name, path_to_str(*path), id]
+             *variant.node.name, path_to_str(*path), id]
       }
       some(node_expr(expr)) {
         #fmt["expr %s (id=%?)",

trunk/src/libsyntax/ast_util.rs

@@ -23,7 +23,10 @@ pure fn dummy_sp() -> span { ret mk_sp(0u, 0u); }
 
 pure fn path_name(p: @path) -> str { path_name_i(p.idents) }
 
-pure fn path_name_i(idents: [ident]) -> str { str::connect(idents, "::") }
+pure fn path_name_i(idents: [ident]) -> str {
+    // FIXME: Bad copies
+    str::connect(idents.map({|i|*i}), "::")
+}
 
 pure fn path_to_ident(p: @path) -> ident { vec::last(p.idents) }
 
@@ -380,7 +383,7 @@ fn dtor_dec() -> fn_decl {
     let nil_t = @{id: 0, node: ty_nil, span: dummy_sp()};
     // dtor has one argument, of type ()
     {inputs: [{mode: ast::expl(ast::by_ref),
-               ty: nil_t, ident: "_", id: 0}],
+               ty: nil_t, ident: @"_", id: 0}],
      output: nil_t, purity: impure_fn, cf: return_val, constraints: []}
 }