---

yaml
---
r: 95961
b: refs/heads/dist-snap
c: dc5d9b9
h: refs/heads/master
i:
  95959: be85e12
v: v3

Author: bors

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 06b2905ee1cea6a693d45de74971e8431cec693f
+refs/heads/dist-snap: dc5d9b908f776bd2a18a8b30f558b6c1cc3f779d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libextra/lib.rs

@@ -21,6 +21,7 @@ Rust extras are part of the standard Rust distribution.
 */
 
 #[link(name = "extra",
+       package_id = "extra",
        vers = "0.9-pre",
        uuid = "122bed0b-c19b-4b82-b0b7-7ae8aead7297",
        url = "https://github.com/mozilla/rust/tree/master/src/libextra")];

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

@@ -634,6 +634,18 @@ pub fn build_link_meta(sess: Session,
         }
     }
 
+    fn crate_meta_pkgid(sess: Session, name: @str, opt_pkg_id: Option<@str>)
+        -> @str {
+        match opt_pkg_id {
+            Some(v) if !v.is_empty() => v,
+            _ => {
+                let pkg_id = name.clone();
+                warn_missing(sess, "package_id", pkg_id);
+                pkg_id
+            }
+        }
+    }
+
     let ProvidedMetas {
         name: opt_name,
         vers: opt_vers,
@@ -642,15 +654,16 @@ pub fn build_link_meta(sess: Session,
     } = provided_link_metas(sess, c);
     let name = crate_meta_name(sess, output, opt_name);
     let vers = crate_meta_vers(sess, opt_vers);
+    let pkg_id = crate_meta_pkgid(sess, name, opt_pkg_id);
     let dep_hashes = cstore::get_dep_hashes(sess.cstore);
     let extras_hash =
         crate_meta_extras_hash(symbol_hasher, cmh_items,
-                               dep_hashes, opt_pkg_id);
+                               dep_hashes, Some(pkg_id));
 
     LinkMeta {
         name: name,
         vers: vers,
-        package_id: opt_pkg_id,
+        package_id: Some(pkg_id),
         extras_hash: extras_hash
     }
 }

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

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 #[link(name = "rustc",
+       package_id = "rustc",
        vers = "0.9-pre",
        uuid = "0ce89b41-2f92-459e-bbc1-8f5fe32f16cf",
        url = "https://github.com/mozilla/rust/tree/master/src/rustc")];

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

@@ -1487,8 +1487,8 @@ fn encode_attributes(ebml_w: &mut writer::Encoder, attrs: &[Attribute]) {
 
 // So there's a special crate attribute called 'link' which defines the
 // 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.
+// 'name', 'vers' and 'package_id' items, so if the user didn't provide them we
+// will throw them in anyway with default values.
 fn synthesize_crate_attrs(ecx: &EncodeContext,
                           crate: &Crate) -> ~[Attribute] {
 
@@ -1505,9 +1505,20 @@ fn synthesize_crate_attrs(ecx: &EncodeContext,
             attr::mk_name_value_item_str(@"vers",
                                          ecx.link_meta.vers);
 
-        let mut meta_items = ~[name_item, vers_item];
+        let pkgid_item = match ecx.link_meta.package_id {
+                Some(pkg_id) =>  attr::mk_name_value_item_str(@"package_id",
+                                                              pkg_id),
+                // uses package_id equal to name;
+                // this should never happen here but package_id is an Option
+                // FIXME (#10370): change package_id in LinkMeta to @str instead of Option<@str>
+                _ => attr::mk_name_value_item_str(@"package_id",
+                                                  ecx.link_meta.name)
+        };
+
+        let mut meta_items = ~[name_item, vers_item, pkgid_item];
 
-        for &mi in items.iter().filter(|mi| "name" != mi.name() && "vers" != mi.name()) {
+        for &mi in items.iter().filter(|mi| "name" != mi.name() && "vers" != mi.name() &&
+                                            "package_id" != mi.name()) {
             meta_items.push(mi);
         }
         let link_item = attr::mk_list_item(@"link", meta_items);

branches/dist-snap/src/librustdoc/lib.rs

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 #[link(name = "rustdoc",
+       package_id = "rustdoc",
        vers = "0.9-pre",
        uuid = "8c6e4598-1596-4aa5-a24c-b811914bbbc6",
        url = "https://github.com/mozilla/rust/tree/master/src/librustdoc")];

branches/dist-snap/src/librustpkg/lib.rs

@@ -11,6 +11,7 @@
 // rustpkg - a package manager and build system for Rust
 
 #[link(name = "rustpkg",
+       package_id = "rustpkg",
        vers = "0.9-pre",
        uuid = "25de5e6e-279e-4a20-845c-4cabae92daaf",
        url = "https://github.com/mozilla/rust/tree/master/src/librustpkg")];

branches/dist-snap/src/librustpkg/tests.rs

@@ -1096,6 +1096,24 @@ fn no_rebuilding() {
     }
 }
 
+#[test]
+fn no_recopying() {
+    let p_id = PkgId::new("foo");
+    let workspace = create_local_package(&p_id);
+    let workspace = workspace.path();
+    command_line_test([~"install", ~"foo"], workspace);
+    let foo_lib = installed_library_in_workspace(&p_id.path, workspace);
+    assert!(foo_lib.is_some());
+    // Now make `foo` read-only so that subsequent attempts to copy to it will fail
+    assert!(chmod_read_only(&foo_lib.unwrap()));
+
+    match command_line_test_partial([~"install", ~"foo"], workspace) {
+        Success(*) => (), // ok
+        Fail(65) => fail!("no_recopying failed: it tried to re-copy foo"),
+        Fail(_) => fail!("no_copying failed for some other reason")
+    }
+}
+
 #[test]
 fn no_rebuilding_dep() {
     let p_id = PkgId::new("foo");

branches/dist-snap/src/librustuv/lib.rs

@@ -35,6 +35,7 @@ via `close` and `delete` methods.
 */
 
 #[link(name = "rustuv",
+       package_id = "rustuv",
        vers = "0.9-pre",
        uuid = "f3719011-0459-9b86-b11c-29265c0d0864",
        url = "https://github.com/mozilla/rust/tree/master/src/librustuv")];

branches/dist-snap/src/libstd/any.rs

@@ -14,6 +14,7 @@
 use cast::transmute;
 use cmp::Eq;
 use option::{Option, Some, None};
+use to_bytes::{IterBytes, Cb};
 use to_str::ToStr;
 use unstable::intrinsics;
 use util::Void;
@@ -42,6 +43,12 @@ impl Eq for TypeId {
     }
 }
 
+impl IterBytes for TypeId {
+    fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
+        self.t.iter_bytes(lsb0, f)
+    }
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // Any trait
 ///////////////////////////////////////////////////////////////////////////////
@@ -175,6 +182,7 @@ mod tests {
     use super::*;
     use super::AnyRefExt;
     use option::{Some, None};
+    use hash::Hash;
 
     #[deriving(Eq)]
     struct Test;
@@ -197,6 +205,13 @@ mod tests {
         assert_eq!(c, f);
     }
 
+    #[test]
+    fn type_id_hash() {
+        let (a, b) = (TypeId::of::<uint>(), TypeId::of::<uint>::());
+
+        assert_eq!(a.hash(), b.hash());
+    }
+
     #[test]
     fn any_as_void_ptr() {
         let (a, b, c) = (~5u as ~Any, ~TEST as ~Any, ~Test as ~Any);

branches/dist-snap/src/libstd/clone.rs

@@ -29,12 +29,27 @@ pub trait Clone {
     /// are copied to maintain uniqueness, while the contents of
     /// managed pointers are not copied.
     fn clone(&self) -> Self;
+
+    /// Perform copy-assignment from `source`.
+    ///
+    /// `a.clone_from(&b)` is equivalent to `a = b.clone()` in functionality,
+    /// but can be overriden to reuse the resources of `a` to avoid unnecessary
+    /// allocations.
+    #[inline(always)]
+    fn clone_from(&mut self, source: &Self) {
+        *self = source.clone()
+    }
 }
 
 impl<T: Clone> Clone for ~T {
-    /// Return a deep copy of the owned box.
+    /// Return a copy of the owned box.
     #[inline]
     fn clone(&self) -> ~T { ~(**self).clone() }
+
+    /// Perform copy-assignment from `source` by reusing the existing allocation.
+    fn clone_from(&mut self, source: &~T) {
+        **self = (**source).clone()
+    }
 }
 
 impl<T> Clone for @T {
@@ -118,16 +133,31 @@ extern_fn_clone!(A, B, C, D, E, F, G, H)
 
 /// A trait distinct from `Clone` which represents "deep copies" of things like
 /// managed boxes which would otherwise not be copied.
-pub trait DeepClone {
+pub trait DeepClone: Clone {
     /// Return a deep copy of the value. Unlike `Clone`, the contents of shared pointer types
     /// *are* copied.
     fn deep_clone(&self) -> Self;
+
+    /// Perform deep copy-assignment from `source`.
+    ///
+    /// `a.deep_clone_from(&b)` is equivalent to `a = b.deep_clone()` in
+    /// functionality, but can be overriden to reuse the resources of `a` to
+    /// avoid unnecessary allocations.
+    #[inline(always)]
+    fn deep_clone_from(&mut self, source: &Self) {
+        *self = source.deep_clone()
+    }
 }
 
 impl<T: DeepClone> DeepClone for ~T {
     /// Return a deep copy of the owned box.
     #[inline]
     fn deep_clone(&self) -> ~T { ~(**self).deep_clone() }
+
+    /// Perform deep copy-assignment from `source` by reusing the existing allocation.
+    fn deep_clone_from(&mut self, source: &~T) {
+        **self = (**source).deep_clone()
+    }
 }
 
 // FIXME: #6525: should also be implemented for `T: Send + DeepClone`
@@ -234,6 +264,22 @@ fn test_borrowed_clone() {
     assert_eq!(*z, 5);
 }
 
+#[test]
+fn test_clone_from() {
+    let a = ~5;
+    let mut b = ~10;
+    b.clone_from(&a);
+    assert_eq!(*b, 5);
+}
+
+#[test]
+fn test_deep_clone_from() {
+    let a = ~5;
+    let mut b = ~10;
+    b.deep_clone_from(&a);
+    assert_eq!(*b, 5);
+}
+
 #[test]
 fn test_extern_fn_clone() {
     trait Empty {}

branches/dist-snap/src/libstd/lib.rs

@@ -44,6 +44,7 @@
 //!     use std::prelude::*;
 
 #[link(name = "std",
+       package_id = "std",
        vers = "0.9-pre",
        uuid = "c70c24a7-5551-4f73-8e37-380b11d80be8",
        url = "https://github.com/mozilla/rust/tree/master/src/libstd")];