---

yaml
---
r: 52301
b: refs/heads/dist-snap
c: dd621bd
h: refs/heads/master
i:
  52299: 4d34153
v: v3

Author: jbclements

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: 44d4d6de762f3f9aae1fedcf454c66b79b3ad58d
-refs/heads/dist-snap: a4dc65baa1caa2ef3e78b3fa8e330dda99d1e752
+refs/heads/dist-snap: dd621bd58d09872333926c3a761a1ee9205e6224
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/librustc/back/link.rs

@@ -457,32 +457,32 @@ mod write {
  *
  */
 
-fn build_link_meta(sess: Session, c: &ast::crate, output: &Path,
+fn build_link_meta(sess: Session, c: ast::crate, output: &Path,
                    symbol_hasher: &hash::State) -> link_meta {
 
     type provided_metas =
-        {name: Option<@str>,
-         vers: Option<@str>,
+        {name: Option<~str>,
+         vers: Option<~str>,
          cmh_items: ~[@ast::meta_item]};
 
-    fn provided_link_metas(sess: Session, c: &ast::crate) ->
+    fn provided_link_metas(sess: Session, c: ast::crate) ->
        provided_metas {
-        let mut name = None;
-        let mut vers = None;
-        let mut cmh_items = ~[];
-        let linkage_metas = attr::find_linkage_metas(c.node.attrs);
-        attr::require_unique_names(sess.diagnostic(), linkage_metas);
+        let mut name: Option<~str> = None;
+        let mut vers: Option<~str> = None;
+        let mut cmh_items: ~[@ast::meta_item] = ~[];
+        let linkage_metas =
+            attr::find_linkage_metas(/*bad*/copy c.node.attrs);
+        // XXX: Bad copy.
+        attr::require_unique_names(sess.diagnostic(), copy linkage_metas);
         for linkage_metas.each |meta| {
             if attr::get_meta_item_name(*meta) == ~"name" {
                 match attr::get_meta_item_value_str(*meta) {
-                  // Changing attr would avoid the need for the copy
-                  // here
-                  Some(v) => { name = Some(v.to_managed()); }
+                  Some(ref v) => { name = Some((/*bad*/copy *v)); }
                   None => cmh_items.push(*meta)
                 }
             } else if attr::get_meta_item_name(*meta) == ~"vers" {
                 match attr::get_meta_item_value_str(*meta) {
-                  Some(v) => { vers = Some(v.to_managed()); }
+                  Some(ref v) => { vers = Some((/*bad*/copy *v)); }
                   None => cmh_items.push(*meta)
                 }
             } else { cmh_items.push(*meta); }
@@ -492,8 +492,9 @@ fn build_link_meta(sess: Session, c: &ast::crate, output: &Path,
 
     // This calculates CMH as defined above
     fn crate_meta_extras_hash(symbol_hasher: &hash::State,
-                              -cmh_items: ~[@ast::meta_item],
-                              dep_hashes: ~[~str]) -> @str {
+                              _crate: ast::crate,
+                              metas: provided_metas,
+                              dep_hashes: ~[~str]) -> ~str {
         fn len_and_str(s: ~str) -> ~str {
             return fmt!("%u_%s", str::len(s), s);
         }
@@ -502,7 +503,7 @@ fn build_link_meta(sess: Session, c: &ast::crate, output: &Path,
             return len_and_str(pprust::lit_to_str(@l));
         }
 
-        let cmh_items = attr::sort_meta_items(cmh_items);
+        let cmh_items = attr::sort_meta_items(/*bad*/copy metas.cmh_items);
 
         symbol_hasher.reset();
         for cmh_items.each |m| {
@@ -525,53 +526,52 @@ fn build_link_meta(sess: Session, c: &ast::crate, output: &Path,
             symbol_hasher.write_str(len_and_str(*dh));
         }
 
-    // tjc: allocation is unfortunate; need to change core::hash
-        return truncated_hash_result(symbol_hasher).to_managed();
+        return truncated_hash_result(symbol_hasher);
     }
 
-    fn warn_missing(sess: Session, name: &str, default: &str) {
+    fn warn_missing(sess: Session, name: ~str, default: ~str) {
         if !sess.building_library { return; }
         sess.warn(fmt!("missing crate link meta `%s`, using `%s` as default",
                        name, default));
     }
 
-    fn crate_meta_name(sess: Session, output: &Path, -opt_name: Option<@str>)
-        -> @str {
-        return match opt_name {
-              Some(v) => v,
+    fn crate_meta_name(sess: Session, _crate: ast::crate,
+                       output: &Path, metas: provided_metas) -> ~str {
+        return match metas.name {
+              Some(ref v) => (/*bad*/copy *v),
               None => {
-                // to_managed could go away if there was a version of
-                // filestem that returned an @str
-                let name = session::expect(sess,
-                                  output.filestem(),
-                                  || fmt!("output file name `%s` doesn't\
+                let name = match output.filestem() {
+                  None => sess.fatal(fmt!("output file name `%s` doesn't\
                                            appear to have a stem",
-                                          output.to_str())).to_managed();
-                warn_missing(sess, ~"name", name);
+                                          output.to_str())),
+                  Some(ref s) => (/*bad*/copy *s)
+                };
+                // XXX: Bad copy.
+                warn_missing(sess, ~"name", copy name);
                 name
               }
             };
     }
 
-    fn crate_meta_vers(sess: Session, opt_vers: Option<@str>) -> @str {
-        return match opt_vers {
-              Some(v) => v,
+    fn crate_meta_vers(sess: Session, _crate: ast::crate,
+                       metas: provided_metas) -> ~str {
+        return match metas.vers {
+              Some(ref v) => (/*bad*/copy *v),
               None => {
-                let vers = @"0.0";
-                warn_missing(sess, ~"vers", vers);
+                let vers = ~"0.0";
+                // Bad copy.
+                warn_missing(sess, ~"vers", copy vers);
                 vers
               }
             };
     }
 
-    let {name: opt_name, vers: opt_vers,
-         cmh_items: cmh_items} = provided_link_metas(sess, c);
-    let name = crate_meta_name(sess, output, move opt_name);
-    let vers = crate_meta_vers(sess, move opt_vers);
+    let provided_metas = provided_link_metas(sess, c);
+    let name = crate_meta_name(sess, c, output, provided_metas);
+    let vers = crate_meta_vers(sess, c, provided_metas);
     let dep_hashes = cstore::get_dep_hashes(sess.cstore);
     let extras_hash =
-        crate_meta_extras_hash(symbol_hasher, move cmh_items,
-                               dep_hashes);
+        crate_meta_extras_hash(symbol_hasher, c, provided_metas, dep_hashes);
 
     return {name: name, vers: vers, extras_hash: extras_hash};
 }
@@ -583,7 +583,7 @@ fn truncated_hash_result(symbol_hasher: &hash::State) -> ~str unsafe {
 
 // This calculates STH for a symbol, as defined above
 fn symbol_hash(tcx: ty::ctxt, symbol_hasher: &hash::State, t: ty::t,
-               link_meta: link_meta) -> @str {
+               link_meta: link_meta) -> ~str {
     // NB: do *not* use abbrevs here as we want the symbol names
     // to be independent of one another in the crate.
 
@@ -593,20 +593,20 @@ fn symbol_hash(tcx: ty::ctxt, symbol_hasher: &hash::State, t: ty::t,
     symbol_hasher.write_str(link_meta.extras_hash);
     symbol_hasher.write_str(~"-");
     symbol_hasher.write_str(encoder::encoded_ty(tcx, t));
-    let mut hash = truncated_hash_result(symbol_hasher);
+    let hash = truncated_hash_result(symbol_hasher);
     // Prefix with _ so that it never blends into adjacent digits
-    str::unshift_char(&mut hash, '_');
-    // tjc: allocation is unfortunate; need to change core::hash
-    hash.to_managed()
+
+    return ~"_" + hash;
 }
 
-fn get_symbol_hash(ccx: @crate_ctxt, t: ty::t) -> @str {
+fn get_symbol_hash(ccx: @crate_ctxt, t: ty::t) -> ~str {
     match ccx.type_hashcodes.find(t) {
-      Some(h) => h,
+      Some(ref h) => return (/*bad*/copy *h),
       None => {
         let hash = symbol_hash(ccx.tcx, ccx.symbol_hasher, t, ccx.link_meta);
-        ccx.type_hashcodes.insert(t, hash);
-        hash
+        // XXX: Bad copy. Prefer `@str`?
+        ccx.type_hashcodes.insert(t, copy hash);
+        return hash;
       }
     }
 }
@@ -664,30 +664,30 @@ fn mangle(sess: Session, ss: path) -> ~str {
 
 fn exported_name(sess: Session,
                  +path: path,
-                 hash: &str,
-                 vers: &str) -> ~str {
+                 +hash: ~str,
+                 +vers: ~str) -> ~str {
     return mangle(sess,
-            vec::append_one(
-            vec::append_one(path, path_name(sess.ident_of(hash.to_owned()))),
-            path_name(sess.ident_of(vers.to_owned()))));
+                  vec::append_one(
+                      vec::append_one(path, path_name(sess.ident_of(hash))),
+                      path_name(sess.ident_of(vers))));
 }
 
 fn mangle_exported_name(ccx: @crate_ctxt, +path: path, t: ty::t) -> ~str {
     let hash = get_symbol_hash(ccx, t);
     return exported_name(ccx.sess, path,
                          hash,
-                         ccx.link_meta.vers);
+                         /*bad*/copy ccx.link_meta.vers);
 }
 
 fn mangle_internal_name_by_type_only(ccx: @crate_ctxt,
                                      t: ty::t,
-                                     name: &str) -> ~str {
+                                     +name: ~str) -> ~str {
     let s = ppaux::ty_to_short_str(ccx.tcx, t);
     let hash = get_symbol_hash(ccx, t);
     return mangle(ccx.sess,
-        ~[path_name(ccx.sess.ident_of(name.to_owned())),
-          path_name(ccx.sess.ident_of(s)),
-          path_name(ccx.sess.ident_of(hash.to_owned()))]);
+                  ~[path_name(ccx.sess.ident_of(name)),
+                    path_name(ccx.sess.ident_of(s)),
+                    path_name(ccx.sess.ident_of(hash))]);
 }
 
 fn mangle_internal_name_by_path_and_seq(ccx: @crate_ctxt,
@@ -706,7 +706,7 @@ fn mangle_internal_name_by_seq(ccx: @crate_ctxt, +flav: ~str) -> ~str {
 }
 
 
-fn output_dll_filename(os: session::os, lm: link_meta) -> ~str {
+fn output_dll_filename(os: session::os, lm: &link_meta) -> ~str {
     let libname = fmt!("%s-%s-%s", lm.name, lm.extras_hash, lm.vers);
     let (dll_prefix, dll_suffix) = match os {
         session::os_win32 => (win32::DLL_PREFIX, win32::DLL_SUFFIX),
@@ -736,7 +736,7 @@ fn link_binary(sess: Session,
     }
 
     let output = if sess.building_library {
-        let long_libname = output_dll_filename(sess.targ_cfg.os, lm);
+        let long_libname = output_dll_filename(sess.targ_cfg.os, &lm);
         debug!("link_meta.name:  %s", lm.name);
         debug!("long_libname: %s", long_libname);
         debug!("out_filename: %s", out_filename.to_str());

branches/dist-snap/src/librustc/driver/driver.rs

@@ -108,7 +108,8 @@ fn default_configuration(sess: Session, +argv0: ~str, input: input) ->
 }
 
 fn append_configuration(+cfg: ast::crate_cfg, +name: ~str) -> ast::crate_cfg {
-    if attr::contains_name(cfg, name) {
+    // XXX: Bad copy.
+    if attr::contains_name(copy cfg, copy name) {
         return cfg;
     } else {
         return vec::append_one(cfg, attr::mk_word_item(name));

branches/dist-snap/src/librustc/front/test.rs

@@ -297,7 +297,7 @@ fn mk_tests(cx: test_ctxt) -> @ast::item {
 
 fn is_std(cx: test_ctxt) -> bool {
     let is_std = {
-        let items = attr::find_linkage_metas(cx.crate.node.attrs);
+        let items = attr::find_linkage_metas(/*bad*/copy cx.crate.node.attrs);
         match attr::last_meta_item_value_str_by_name(items, ~"name") {
           Some(~"std") => true,
           _ => false

branches/dist-snap/src/librustc/metadata/common.rs

@@ -152,5 +152,5 @@ const tag_lang_items_item: uint = 0x73;
 const tag_lang_items_item_id: uint = 0x74;
 const tag_lang_items_item_node_id: uint = 0x75;
 
-type link_meta = {name: @str, vers: @str, extras_hash: @str};
+type link_meta = {name: ~str, vers: ~str, extras_hash: ~str};
 

branches/dist-snap/src/librustc/metadata/creader.rs

@@ -191,7 +191,8 @@ fn visit_item(e: env, i: @ast::item) {
 
 fn metas_with(+ident: ~str, +key: ~str, +metas: ~[@ast::meta_item])
     -> ~[@ast::meta_item] {
-    let name_items = attr::find_meta_items_by_name(metas, key);
+    // XXX: Bad copies.
+    let name_items = attr::find_meta_items_by_name(copy metas, copy key);
     if name_items.is_empty() {
         vec::append_one(metas, attr::mk_name_value_item_str(key, ident))
     } else {

branches/dist-snap/src/librustc/metadata/encoder.rs

@@ -881,7 +881,7 @@ fn encode_info_for_foreign_item(ecx: @encode_ctxt,
 }
 
 fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: writer::Encoder,
-                         crate: &crate) -> ~[entry<int>] {
+                         crate: @crate) -> ~[entry<int>] {
     let index = @mut ~[];
     ebml_w.start_tag(tag_items_data);
     index.push({val: crate_node_id, pos: ebml_w.writer.tell()});
@@ -1021,20 +1021,20 @@ fn encode_attributes(ebml_w: writer::Encoder, attrs: ~[attribute]) {
 // metadata that Rust cares about for linking crates. This attribute requires
 // 'name' and 'vers' items, so if the user didn't provide them we will throw
 // them in anyway with default values.
-fn synthesize_crate_attrs(ecx: @encode_ctxt, crate: &crate) -> ~[attribute] {
+fn synthesize_crate_attrs(ecx: @encode_ctxt, crate: @crate) -> ~[attribute] {
 
     fn synthesize_link_attr(ecx: @encode_ctxt, +items: ~[@meta_item]) ->
        attribute {
 
-        assert ecx.link_meta.name.is_not_empty();
-        assert ecx.link_meta.vers.is_not_empty();
+        assert (ecx.link_meta.name != ~"");
+        assert (ecx.link_meta.vers != ~"");
 
         let name_item =
             attr::mk_name_value_item_str(~"name",
-                                         ecx.link_meta.name.to_owned());
+                                         /*bad*/copy ecx.link_meta.name);
         let vers_item =
             attr::mk_name_value_item_str(~"vers",
-                                         ecx.link_meta.vers.to_owned());
+                                         /*bad*/copy ecx.link_meta.vers);
 
         let other_items =
             {
@@ -1156,7 +1156,7 @@ fn encode_crate_dep(ecx: @encode_ctxt, ebml_w: writer::Encoder,
     ebml_w.end_tag();
 }
 
-fn encode_hash(ebml_w: writer::Encoder, hash: &str) {
+fn encode_hash(ebml_w: writer::Encoder, hash: ~str) {
     ebml_w.start_tag(tag_crate_hash);
     ebml_w.writer.write(str::to_bytes(hash));
     ebml_w.end_tag();
@@ -1169,7 +1169,7 @@ const metadata_encoding_version : &[u8] = &[0x72, //'r' as u8,
                                             0x74, //'t' as u8,
                                             0, 0, 0, 1 ];
 
-fn encode_metadata(parms: encode_parms, crate: &crate) -> ~[u8] {
+fn encode_metadata(parms: encode_parms, crate: @crate) -> ~[u8] {
     let wr = @io::BytesWriter();
     let stats =
         {mut inline_bytes: 0,
@@ -1197,7 +1197,7 @@ fn encode_metadata(parms: encode_parms, crate: &crate) -> ~[u8] {
 
     let ebml_w = writer::Encoder(wr as io::Writer);
 
-    encode_hash(ebml_w, ecx.link_meta.extras_hash);
+    encode_hash(ebml_w, /*bad*/copy ecx.link_meta.extras_hash);
 
     let mut i = wr.pos;
     let crate_attrs = synthesize_crate_attrs(ecx, crate);

branches/dist-snap/src/librustc/metadata/loader.rs

@@ -77,7 +77,7 @@ fn load_library_crate(cx: ctxt) -> {ident: ~str, data: @~[u8]} {
 }
 
 fn find_library_crate(cx: ctxt) -> Option<{ident: ~str, data: @~[u8]}> {
-    attr::require_unique_names(cx.diag, cx.metas);
+    attr::require_unique_names(cx.diag, /*bad*/copy cx.metas);
     find_library_crate_aux(cx, libname(cx), cx.filesearch)
 }
 

branches/dist-snap/src/librustc/middle/borrowck/preserve.rs

@@ -106,9 +106,6 @@ priv impl &preserve_ctxt {
             let scope_region = if self.root_ub == 0 {
                 ty::re_static
             } else {
-                // Maybe if we pass in the parent instead here,
-                // we can prevent the "scope not found" error
-                debug!("scope_region thing: %? ", cmt.id);
                 ty::re_scope(self.tcx().region_map.get(cmt.id))
             };