---

yaml
---
r: 107861
b: refs/heads/dist-snap
c: 9869374
h: refs/heads/master
i:
  107859: 0a88e4d
v: v3

Author: pcwalton

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: f64fdf524a434f0e5cd0bc91d09c144723f3c90d
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: b890237e798030ce337933b14f777a1c3810d1ea
+refs/heads/dist-snap: 986937425636c3174dfe11bb6309865e8a1e0350
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

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

@@ -473,10 +473,10 @@ pub fn build_link_meta(sess: Session,
                        symbol_hasher: &mut Sha256)
                        -> LinkMeta {
     // This calculates CMH as defined above
-    fn crate_hash(symbol_hasher: &mut Sha256, crateid: &CrateId) -> @str {
+    fn crate_hash(symbol_hasher: &mut Sha256, crateid: &CrateId) -> ~str {
         symbol_hasher.reset();
         symbol_hasher.input_str(crateid.to_str());
-        truncated_hash_result(symbol_hasher).to_managed()
+        truncated_hash_result(symbol_hasher)
     }
 
     let crateid = match attr::find_crateid(attrs) {
@@ -963,7 +963,7 @@ fn link_staticlib(sess: Session, obj_filename: &Path, out_filename: &Path) {
 
     let crates = sess.cstore.get_used_crates(cstore::RequireStatic);
     for &(cnum, ref path) in crates.iter() {
-        let name = sess.cstore.get_crate_data(cnum).name;
+        let name = sess.cstore.get_crate_data(cnum).name.clone();
         let p = match *path {
             Some(ref p) => p.clone(), None => {
                 sess.err(format!("could not find rlib for: `{}`", name));
@@ -1221,7 +1221,7 @@ fn add_upstream_rust_crates(args: &mut ~[~str], sess: Session,
                 // If we're not doing LTO, then our job is simply to just link
                 // against the archive.
                 if sess.lto() {
-                    let name = sess.cstore.get_crate_data(cnum).name;
+                    let name = sess.cstore.get_crate_data(cnum).name.clone();
                     time(sess.time_passes(), format!("altering {}.rlib", name),
                          (), |()| {
                         let dst = tmpdir.join(cratepath.filename().unwrap());

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

@@ -42,7 +42,7 @@ pub fn run(sess: session::Session, llmod: ModuleRef,
     // module that we've got.
     let crates = sess.cstore.get_used_crates(cstore::RequireStatic);
     for (cnum, path) in crates.move_iter() {
-        let name = sess.cstore.get_crate_data(cnum).name;
+        let name = sess.cstore.get_crate_data(cnum).name.clone();
         let path = match path {
             Some(p) => p,
             None => {

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

@@ -210,5 +210,5 @@ pub static tag_macro_def: uint = 0x112;
 #[deriving(Clone)]
 pub struct LinkMeta {
     crateid: CrateId,
-    crate_hash: @str,
+    crate_hash: ~str,
 }

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

@@ -76,7 +76,7 @@ impl<'a> visit::Visitor<()> for ReadCrateVisitor<'a> {
 struct cache_entry {
     cnum: ast::CrateNum,
     span: Span,
-    hash: @str,
+    hash: ~str,
     crateid: CrateId,
 }
 
@@ -146,45 +146,49 @@ fn visit_view_item(e: &mut Env, i: &ast::ViewItem) {
 
     match extract_crate_info(i) {
         Some(info) => {
-            let cnum = resolve_crate(e, info.ident, info.name, info.version,
-                                     @"", i.span);
+            let cnum = resolve_crate(e,
+                                     info.ident.clone(),
+                                     info.name.clone(),
+                                     info.version.clone(),
+                                     ~"",
+                                     i.span);
             e.sess.cstore.add_extern_mod_stmt_cnum(info.id, cnum);
         }
         None => ()
     }
 }
 
 struct CrateInfo {
-    ident: @str,
-    name: @str,
-    version: @str,
+    ident: ~str,
+    name: ~str,
+    version: ~str,
     id: ast::NodeId,
 }
 
 fn extract_crate_info(i: &ast::ViewItem) -> Option<CrateInfo> {
     match i.node {
         ast::ViewItemExternMod(ref ident, ref path_opt, id) => {
-            let ident = token::ident_to_str(ident);
+            let ident = token::get_ident(ident.name);
             debug!("resolving extern mod stmt. ident: {:?} path_opt: {:?}",
-                   ident, path_opt);
+                   ident.get(), path_opt);
             let (name, version) = match *path_opt {
                 Some((ref path_str, _)) => {
                     let crateid: Option<CrateId> = from_str(path_str.get());
                     match crateid {
-                        None => (@"", @""),
+                        None => (~"", ~""),
                         Some(crateid) => {
                             let version = match crateid.version {
-                                None => @"",
-                                Some(ref ver) => ver.to_managed(),
+                                None => ~"",
+                                Some(ref ver) => ver.to_str(),
                             };
-                            (crateid.name.to_managed(), version)
+                            (crateid.name.to_str(), version)
                         }
                     }
                 }
-                None => (ident, @""),
+                None => (ident.get().to_str(), ~""),
             };
             Some(CrateInfo {
-                  ident: ident,
+                  ident: ident.get().to_str(),
                   name: name,
                   version: version,
                   id: id,
@@ -278,14 +282,14 @@ fn visit_item(e: &Env, i: &ast::Item) {
     }
 }
 
-fn existing_match(e: &Env, name: @str, version: @str, hash: &str) -> Option<ast::CrateNum> {
+fn existing_match(e: &Env, name: ~str, version: ~str, hash: &str) -> Option<ast::CrateNum> {
     let crate_cache = e.crate_cache.borrow();
     for c in crate_cache.get().iter() {
         let crateid_version = match c.crateid.version {
-            None => @"0.0",
-            Some(ref ver) => ver.to_managed(),
+            None => ~"0.0",
+            Some(ref ver) => ver.to_str(),
         };
-        if (name.is_empty() || c.crateid.name.to_managed() == name) &&
+        if (name.is_empty() || c.crateid.name == name) &&
             (version.is_empty() || crateid_version == version) &&
             (hash.is_empty() || c.hash.as_slice() == hash) {
             return Some(c.cnum);
@@ -295,19 +299,19 @@ fn existing_match(e: &Env, name: @str, version: @str, hash: &str) -> Option<ast:
 }
 
 fn resolve_crate(e: &mut Env,
-                 ident: @str,
-                 name: @str,
-                 version: @str,
-                 hash: @str,
+                 ident: ~str,
+                 name: ~str,
+                 version: ~str,
+                 hash: ~str,
                  span: Span)
               -> ast::CrateNum {
-    match existing_match(e, name, version, hash) {
+    match existing_match(e, name.clone(), version.clone(), hash.clone()) {
       None => {
         let load_ctxt = loader::Context {
             sess: e.sess,
             span: span,
             ident: ident,
-            name: name,
+            name: name.clone(),
             version: version,
             hash: hash,
             os: e.os,
@@ -368,10 +372,13 @@ fn resolve_crate_deps(e: &mut Env, cdata: &[u8]) -> cstore::cnum_map {
     let r = decoder::get_crate_deps(cdata);
     for dep in r.iter() {
         let extrn_cnum = dep.cnum;
-        let cname_str = token::ident_to_str(&dep.name);
+        let cname_str = token::get_ident(dep.name.name);
         debug!("resolving dep crate {} ver: {} hash: {}",
                cname_str, dep.vers, dep.hash);
-        match existing_match(e, cname_str, dep.vers, dep.hash) {
+        match existing_match(e,
+                             cname_str.get().to_str(),
+                             dep.vers.clone(),
+                             dep.hash.clone()) {
           Some(local_cnum) => {
             debug!("already have it");
             // We've already seen this crate
@@ -383,8 +390,12 @@ fn resolve_crate_deps(e: &mut Env, cdata: &[u8]) -> cstore::cnum_map {
             // FIXME (#2404): Need better error reporting than just a bogus
             // span.
             let fake_span = DUMMY_SP;
-            let local_cnum = resolve_crate(e, cname_str, cname_str, dep.vers,
-                                           dep.hash, fake_span);
+            let local_cnum = resolve_crate(e,
+                                           cname_str.get().to_str(),
+                                           cname_str.get().to_str(),
+                                           dep.vers.clone(),
+                                           dep.hash.clone(),
+                                           fake_span);
             cnum_map.insert(extrn_cnum, local_cnum);
           }
         }
@@ -415,8 +426,12 @@ impl Loader {
 impl CrateLoader for Loader {
     fn load_crate(&mut self, crate: &ast::ViewItem) -> MacroCrate {
         let info = extract_crate_info(crate).unwrap();
-        let cnum = resolve_crate(&mut self.env, info.ident, info.name,
-                                 info.version, @"", crate.span);
+        let cnum = resolve_crate(&mut self.env,
+                                 info.ident.clone(),
+                                 info.name.clone(),
+                                 info.version.clone(),
+                                 ~"",
+                                 crate.span);
         let library = self.env.sess.cstore.get_used_crate_source(cnum).unwrap();
         MacroCrate {
             lib: library.dylib,

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

@@ -32,7 +32,7 @@ pub enum MetadataBlob {
 }
 
 pub struct crate_metadata {
-    name: @str,
+    name: ~str,
     data: MetadataBlob,
     cnum_map: cnum_map,
     cnum: ast::CrateNum
@@ -89,12 +89,12 @@ impl CStore {
         *metas.get().get(&cnum)
     }
 
-    pub fn get_crate_hash(&self, cnum: ast::CrateNum) -> @str {
+    pub fn get_crate_hash(&self, cnum: ast::CrateNum) -> ~str {
         let cdata = self.get_crate_data(cnum);
         decoder::get_crate_hash(cdata.data())
     }
 
-    pub fn get_crate_vers(&self, cnum: ast::CrateNum) -> @str {
+    pub fn get_crate_vers(&self, cnum: ast::CrateNum) -> ~str {
         let cdata = self.get_crate_data(cnum);
         decoder::get_crate_vers(cdata.data())
     }
@@ -192,7 +192,7 @@ impl CStore {
 
     // returns hashes of crates directly used by this crate. Hashes are sorted by
     // (crate name, crate version, crate hash) in lexicographic order (not semver)
-    pub fn get_dep_hashes(&self) -> ~[@str] {
+    pub fn get_dep_hashes(&self) -> ~[~str] {
         let mut result = ~[];
 
         let extern_mod_crate_map = self.extern_mod_crate_map.borrow();
@@ -202,7 +202,7 @@ impl CStore {
             let vers = decoder::get_crate_vers(cdata.data());
             debug!("Add hash[{}]: {} {}", cdata.name, vers, hash);
             result.push(crate_hash {
-                name: cdata.name,
+                name: cdata.name.clone(),
                 vers: vers,
                 hash: hash
             });
@@ -215,15 +215,23 @@ impl CStore {
             debug!("  hash[{}]: {}", x.name, x.hash);
         }
 
-        result.map(|ch| ch.hash)
+        let mut hashes = ~[];
+        for ch in result.move_iter() {
+            let crate_hash {
+                hash,
+                ..
+            } = ch;
+            hashes.push(hash)
+        }
+        hashes
     }
 }
 
 #[deriving(Clone, TotalEq, TotalOrd)]
 struct crate_hash {
-    name: @str,
-    vers: @str,
-    hash: @str,
+    name: ~str,
+    vers: ~str,
+    hash: ~str,
 }
 
 impl crate_metadata {

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

@@ -1113,18 +1113,18 @@ pub fn get_crate_attributes(data: &[u8]) -> ~[ast::Attribute] {
 pub struct CrateDep {
     cnum: ast::CrateNum,
     name: ast::Ident,
-    vers: @str,
-    hash: @str
+    vers: ~str,
+    hash: ~str
 }
 
 pub fn get_crate_deps(data: &[u8]) -> ~[CrateDep] {
     let mut deps: ~[CrateDep] = ~[];
     let cratedoc = reader::Doc(data);
     let depsdoc = reader::get_doc(cratedoc, tag_crate_deps);
     let mut crate_num = 1;
-    fn docstr(doc: ebml::Doc, tag_: uint) -> @str {
+    fn docstr(doc: ebml::Doc, tag_: uint) -> ~str {
         let d = reader::get_doc(doc, tag_);
-        d.as_str_slice().to_managed()
+        d.as_str_slice().to_str()
     }
     reader::tagged_docs(depsdoc, tag_crate_dep, |depdoc| {
         deps.push(CrateDep {cnum: crate_num,
@@ -1149,17 +1149,17 @@ fn list_crate_deps(data: &[u8], out: &mut io::Writer) {
     write!(out, "\n");
 }
 
-pub fn get_crate_hash(data: &[u8]) -> @str {
+pub fn get_crate_hash(data: &[u8]) -> ~str {
     let cratedoc = reader::Doc(data);
     let hashdoc = reader::get_doc(cratedoc, tag_crate_hash);
-    hashdoc.as_str_slice().to_managed()
+    hashdoc.as_str_slice().to_str()
 }
 
-pub fn get_crate_vers(data: &[u8]) -> @str {
+pub fn get_crate_vers(data: &[u8]) -> ~str {
     let attrs = decoder::get_crate_attributes(data);
     match attr::find_crateid(attrs) {
-        None => @"0.0",
-        Some(crateid) => crateid.version_or_default().to_managed(),
+        None => ~"0.0",
+        Some(crateid) => crateid.version_or_default().to_str(),
     }
 }
 

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

@@ -1614,7 +1614,7 @@ fn encode_crate_deps(ecx: &EncodeContext,
     ebml_w.start_tag(tag_crate_deps);
     let r = get_ordered_deps(ecx, cstore);
     for dep in r.iter() {
-        encode_crate_dep(ecx, ebml_w, *dep);
+        encode_crate_dep(ecx, ebml_w, (*dep).clone());
     }
     ebml_w.end_tag();
 }