---

yaml
---
r: 61410
b: refs/heads/try
c: f89e00b
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2d28d645422c1617be58c8ca7ad9a457264ca850
-refs/heads/try: 65b7903ba3aab91c68d09e192f907a68b7308ee4
+refs/heads/try: f89e00b3d149d78b8fe21251912d9c7fa78b9f15
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/.swo

@@ -1562,7 +1562,7 @@ Supported traits for `deriving` are:
 
 * Comparison traits: `Eq`, `TotalEq`, `Ord`, `TotalOrd`.
 * Serialization: `Encodable`, `Decodable`. These require `std`.
-* `Clone`, to perform deep copies.
+* `Clone` and `DeepClone`, to perform (deep) copies.
 * `IterBytes`, to iterate over the bytes in a data type.
 * `Rand`, to create a random instance of a data type.
 * `ToStr`, to convert to a string. For a type with this instance,

branches/try/doc/rust.md

@@ -2308,8 +2308,8 @@ enum ABC { A, B, C }
 ~~~
 
 The full list of derivable traits is `Eq`, `TotalEq`, `Ord`,
-`TotalOrd`, `Encodable` `Decodable`, `Clone`, `IterBytes`, `Rand` and
-`ToStr`.
+`TotalOrd`, `Encodable` `Decodable`, `Clone`, `DeepClone`,
+`IterBytes`, `Rand` and `ToStr`.
 
 # Modules and crates
 

branches/try/doc/tutorial.md

@@ -149,7 +149,7 @@ pub fn from_elem<T:Copy>(n_elts: uint, t: T) -> @[T] {
  * Creates and initializes an immutable managed vector by moving all the
  * elements from an owned vector.
  */
-pub fn from_owned<T>(v: ~[T]) -> @[T] {
+pub fn to_managed_consume<T>(v: ~[T]) -> @[T] {
     let mut av = @[];
     unsafe {
         raw::reserve(&mut av, v.len());
@@ -164,7 +164,7 @@ pub fn from_owned<T>(v: ~[T]) -> @[T] {
  * Creates and initializes an immutable managed vector by copying all the
  * elements of a slice.
  */
-pub fn from_slice<T:Copy>(v: &[T]) -> @[T] {
+pub fn to_managed<T:Copy>(v: &[T]) -> @[T] {
     from_fn(v.len(), |i| v[i])
 }
 
@@ -304,20 +304,20 @@ mod test {
     }
 
     #[test]
-    fn test_from_owned() {
-        assert!(from_owned::<int>(~[]) == @[]);
-        assert!(from_owned(~[true]) == @[true]);
-        assert!(from_owned(~[1, 2, 3, 4, 5]) == @[1, 2, 3, 4, 5]);
-        assert!(from_owned(~[~"abc", ~"123"]) == @[~"abc", ~"123"]);
-        assert!(from_owned(~[~[42]]) == @[~[42]]);
+    fn test_to_managed_consume() {
+        assert!(to_managed_consume::<int>(~[]) == @[]);
+        assert!(to_managed_consume(~[true]) == @[true]);
+        assert!(to_managed_consume(~[1, 2, 3, 4, 5]) == @[1, 2, 3, 4, 5]);
+        assert!(to_managed_consume(~[~"abc", ~"123"]) == @[~"abc", ~"123"]);
+        assert!(to_managed_consume(~[~[42]]) == @[~[42]]);
     }
 
     #[test]
-    fn test_from_slice() {
-        assert!(from_slice::<int>([]) == @[]);
-        assert!(from_slice([true]) == @[true]);
-        assert!(from_slice([1, 2, 3, 4, 5]) == @[1, 2, 3, 4, 5]);
-        assert!(from_slice([@"abc", @"123"]) == @[@"abc", @"123"]);
-        assert!(from_slice([@[42]]) == @[@[42]]);
+    fn test_to_managed() {
+        assert!(to_managed::<int>([]) == @[]);
+        assert!(to_managed([true]) == @[true]);
+        assert!(to_managed([1, 2, 3, 4, 5]) == @[1, 2, 3, 4, 5]);
+        assert!(to_managed([@"abc", @"123"]) == @[@"abc", @"123"]);
+        assert!(to_managed([@[42]]) == @[@[42]]);
     }
 }

branches/try/src/libcore/at_vec.rs

@@ -22,6 +22,8 @@ by convention implementing the `Clone` trait and calling the
 
 */
 
+use core::kinds::Const;
+
 pub trait Clone {
     /// Return a deep copy of the owned object tree. Types with shared ownership like managed boxes
     /// are cloned with a shallow copy.
@@ -46,6 +48,12 @@ impl<T> Clone for @mut T {
     fn clone(&self) -> @mut T { *self }
 }
 
+impl<'self, T> Clone for &'self T {
+    /// Return a shallow copy of the borrowed pointer.
+    #[inline(always)]
+    fn clone(&self) -> &'self T { *self }
+}
+
 macro_rules! clone_impl(
     ($t:ty) => {
         impl Clone for $t {
@@ -78,11 +86,32 @@ clone_impl!(char)
 
 pub trait DeepClone {
     /// Return a deep copy of the object tree. Types with shared ownership are also copied via a
-    /// deep copy, unlike `Clone`. Note that this is currently unimplemented for managed boxes, as
-    /// it would need to handle cycles.
+    /// deep copy, unlike `Clone`.
     fn deep_clone(&self) -> Self;
 }
 
+impl<T: DeepClone> DeepClone for ~T {
+    /// Return a deep copy of the owned box.
+    #[inline(always)]
+    fn deep_clone(&self) -> ~T { ~(**self).deep_clone() }
+}
+
+// FIXME: #6525: should also be implemented for `T: Owned + DeepClone`
+impl<T: Const + DeepClone> DeepClone for @T {
+    /// Return a deep copy of the managed box. The `Const` trait is required to prevent performing
+    /// a deep clone of a potentially cyclical type.
+    #[inline(always)]
+    fn deep_clone(&self) -> @T { @(**self).deep_clone() }
+}
+
+// FIXME: #6525: should also be implemented for `T: Owned + DeepClone`
+impl<T: Const + DeepClone> DeepClone for @mut T {
+    /// Return a deep copy of the managed box. The `Const` trait is required to prevent performing
+    /// a deep clone of a potentially cyclical type.
+    #[inline(always)]
+    fn deep_clone(&self) -> @mut T { @mut (**self).deep_clone() }
+}
+
 macro_rules! deep_clone_impl(
     ($t:ty) => {
         impl DeepClone for $t {
@@ -93,12 +122,6 @@ macro_rules! deep_clone_impl(
     }
 )
 
-impl<T: DeepClone> DeepClone for ~T {
-    /// Return a deep copy of the owned box.
-    #[inline(always)]
-    fn deep_clone(&self) -> ~T { ~(**self).deep_clone() }
-}
-
 deep_clone_impl!(int)
 deep_clone_impl!(i8)
 deep_clone_impl!(i16)
@@ -121,23 +144,39 @@ deep_clone_impl!(char)
 
 #[test]
 fn test_owned_clone() {
-    let a: ~int = ~5i;
+    let a = ~5i;
     let b: ~int = a.clone();
     assert!(a == b);
 }
 
 #[test]
 fn test_managed_clone() {
-    let a: @int = @5i;
+    let a = @5i;
     let b: @int = a.clone();
     assert!(a == b);
 }
 
+#[test]
+fn test_managed_mut_deep_clone() {
+    let x = @mut 5i;
+    let y: @mut int = x.deep_clone();
+    *x = 20;
+    assert_eq!(*y, 5);
+}
+
 #[test]
 fn test_managed_mut_clone() {
-    let a: @mut int = @mut 5i;
+    let a = @mut 5i;
     let b: @mut int = a.clone();
     assert!(a == b);
     *b = 10;
     assert!(a == b);
 }
+
+#[test]
+fn test_borrowed_clone() {
+    let x = 5i;
+    let y: &int = &x;
+    let z: &int = (&y).clone();
+    assert_eq!(*z, 5);
+}

branches/try/src/libcore/clone.rs

@@ -825,6 +825,10 @@ pub impl <T:Hash + Eq> HashSet<T> {
     fn consume(&mut self, f: &fn(T)) {
         self.map.consume(|k, _| f(k))
     }
+
+    fn contains_equiv<Q:Hash + Equiv<T>>(&self, value: &Q) -> bool {
+      self.map.contains_key_equiv(value)
+    }
 }
 
 #[cfg(test)]

branches/try/src/libcore/hashmap.rs

@@ -289,6 +289,33 @@ pub fn setenv(n: &str, v: &str) {
     }
 }
 
+/// Remove a variable from the environment entirely
+pub fn unsetenv(n: &str) {
+    #[cfg(unix)]
+    fn _unsetenv(n: &str) {
+        unsafe {
+            do with_env_lock {
+                do str::as_c_str(n) |nbuf| {
+                    libc::funcs::posix01::unistd::unsetenv(nbuf);
+                }
+            }
+        }
+    }
+    #[cfg(windows)]
+    fn _unsetenv(n: &str) {
+        unsafe {
+            do with_env_lock {
+                use os::win32::as_utf16_p;
+                do as_utf16_p(n) |nbuf| {
+                    libc::SetEnvironmentVariableW(nbuf, ptr::null());
+                }
+            }
+        }
+    }
+
+    _unsetenv(n);
+}
+
 pub fn fdopen(fd: c_int) -> *FILE {
     unsafe {
         return do as_c_charp("r") |modebuf| {
@@ -1412,7 +1439,7 @@ mod tests {
     use option::Some;
     use option;
     use os::{as_c_charp, env, getcwd, getenv, make_absolute, real_args};
-    use os::{remove_file, setenv};
+    use os::{remove_file, setenv, unsetenv};
     use os;
     use path::Path;
     use rand::RngUtil;
@@ -1448,6 +1475,14 @@ mod tests {
         assert!(getenv(n) == option::Some(~"VALUE"));
     }
 
+    #[test]
+    fn test_unsetenv() {
+        let n = make_rand_name();
+        setenv(n, ~"VALUE");
+        unsetenv(n);
+        assert!(getenv(n) == option::None);
+    }
+
     #[test]
     #[ignore(cfg(windows))]
     #[ignore]

branches/try/src/libcore/os.rs

@@ -2546,23 +2546,29 @@ pub mod raw {
      * would also make any pointers to it invalid.
      */
     #[inline(always)]
-    pub unsafe fn to_ptr<T>(v: &[T]) -> *T {
-        let repr: **SliceRepr = transmute(&v);
-        transmute(&((**repr).data))
+    pub fn to_ptr<T>(v: &[T]) -> *T {
+        unsafe {
+            let repr: **SliceRepr = transmute(&v);
+            transmute(&((**repr).data))
+        }
     }
 
     /** see `to_ptr()` */
     #[inline(always)]
-    pub unsafe fn to_const_ptr<T>(v: &const [T]) -> *const T {
-        let repr: **SliceRepr = transmute(&v);
-        transmute(&((**repr).data))
+    pub fn to_const_ptr<T>(v: &const [T]) -> *const T {
+        unsafe {
+            let repr: **SliceRepr = transmute(&v);
+            transmute(&((**repr).data))
+        }
     }
 
     /** see `to_ptr()` */
     #[inline(always)]
-    pub unsafe fn to_mut_ptr<T>(v: &mut [T]) -> *mut T {
-        let repr: **SliceRepr = transmute(&v);
-        transmute(&((**repr).data))
+    pub fn to_mut_ptr<T>(v: &mut [T]) -> *mut T {
+        unsafe {
+            let repr: **SliceRepr = transmute(&v);
+            transmute(&((**repr).data))
+        }
     }
 
     /**

branches/try/src/libcore/vec.rs

@@ -35,19 +35,19 @@ ASTs -- are in a separate crate called "syntax", whose files are in
 ./../libsyntax, where . is the current directory (that is, the parent
 directory of front/, middle/, back/, and so on).
 
-The entry-point for the compiler is main() in driver/rustc.rs, and
+The entry-point for the compiler is main() in rustc.rc, and
 this file sequences the various parts together.
 
 
 The 3 central data structures:
 ------------------------------
 
-#1: ../libsyntax/ast.rs defines the AST. The AST is treated as immutable
+#1: ./../libsyntax/ast.rs defines the AST. The AST is treated as immutable
     after parsing, but it depends on mutable context data structures
     (mainly hash maps) to give it meaning.
 
       - Many -- though not all -- nodes within this data structure are
-        wrapped in the type spanned<T>, meaning that the front-end has
+        wrapped in the type `spanned<T>`, meaning that the front-end has
         marked the input coordinates of that node. The member .node is
         the data itself, the member .span is the input location (file,
         line, column; both low and high).
@@ -78,7 +78,7 @@ Control and information flow within the compiler:
 - main() in rustc.rc assumes control on startup. Options are
   parsed, platform is detected, etc.
 
-- libsyntax/parse/parser.rs parses the input files and produces an AST
+- ./../libsyntax/parse/parser.rs parses the input files and produces an AST
   that represents the input crate.
 
 - Multiple middle-end passes (middle/resolve.rs, middle/typeck.rs)

branches/try/src/librustc/README.txt

@@ -470,12 +470,14 @@ fn parse_closure_ty(st: @mut PState, conv: conv_did) -> ty::ClosureTy {
     let purity = parse_purity(next(st));
     let onceness = parse_onceness(next(st));
     let region = parse_region(st);
+    let bounds = parse_bounds(st, conv);
     let sig = parse_sig(st, conv);
     ty::ClosureTy {
         purity: purity,
         sigil: sigil,
         onceness: onceness,
         region: region,
+        bounds: bounds.builtin_bounds,
         sig: sig
     }
 }
@@ -540,10 +542,10 @@ pub fn parse_type_param_def_data(data: @~[u8], start: uint,
 
 fn parse_type_param_def(st: @mut PState, conv: conv_did) -> ty::TypeParameterDef {
     ty::TypeParameterDef {def_id: parse_def(st, NominalType, conv),
-                          bounds: parse_bounds(st, conv)}
+                          bounds: @parse_bounds(st, conv)}
 }
 
-fn parse_bounds(st: @mut PState, conv: conv_did) -> @ty::ParamBounds {
+fn parse_bounds(st: @mut PState, conv: conv_did) -> ty::ParamBounds {
     let mut param_bounds = ty::ParamBounds {
         builtin_bounds: ty::EmptyBuiltinBounds(),
         trait_bounds: ~[]
@@ -566,7 +568,7 @@ fn parse_bounds(st: @mut PState, conv: conv_did) -> @ty::ParamBounds {
                 param_bounds.trait_bounds.push(@parse_trait_ref(st, conv));
             }
             '.' => {
-                return @param_bounds;
+                return param_bounds;
             }
             _ => {
                 fail!("parse_bounds: bad bounds")

branches/try/src/librustc/metadata/tydecode.rs

@@ -380,6 +380,9 @@ fn enc_closure_ty(w: @io::Writer, cx: @ctxt, ft: &ty::ClosureTy) {
     enc_purity(w, ft.purity);
     enc_onceness(w, ft.onceness);
     enc_region(w, cx, ft.region);
+    let bounds = ty::ParamBounds {builtin_bounds: ft.bounds,
+                                  trait_bounds: ~[]};
+    enc_bounds(w, cx, &bounds);
     enc_fn_sig(w, cx, &ft.sig);
 }
 
@@ -392,7 +395,7 @@ fn enc_fn_sig(w: @io::Writer, cx: @ctxt, fsig: &ty::FnSig) {
     enc_ty(w, cx, fsig.output);
 }
 
-fn enc_bounds(w: @io::Writer, cx: @ctxt, bs: @ty::ParamBounds) {
+fn enc_bounds(w: @io::Writer, cx: @ctxt, bs: &ty::ParamBounds) {
     for bs.builtin_bounds.each |bound| {
         match bound {
             ty::BoundOwned => w.write_char('S'),

branches/try/src/librustc/metadata/tyencode.rs

@@ -1108,7 +1108,7 @@ fn decode_side_tables(xcx: @ExtendedDecodeContext,
                 dcx.tcx.adjustments.insert(id, adj);
             } else if tag == (c::tag_table_capture_map as uint) {
                 let cvars =
-                    at_vec::from_owned(
+                    at_vec::to_managed_consume(
                         val_dsr.read_to_vec(
                             |val_dsr| val_dsr.read_capture_var(xcx)));
                 dcx.maps.capture_map.insert(id, cvars);