---

yaml
---
r: 210427
b: refs/heads/try
c: 391d148
h: refs/heads/master
i:
  210425: ee4489c
  210423: 7d93279
v: v3

Author: astraw

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 3e561f05c00cd180ec02db4ccab2840a4aba93d2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ba0e1cd8147d452c356aacb29fb87568ca26f111
-refs/heads/try: 7132092ce6e954eb58d490fa886d0865c5cfba38
+refs/heads/try: 391d14802eaa8ef694ebbb70d785227156e4bf32
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/src/doc/trpl/mutability.md

@@ -85,7 +85,7 @@ safety, and the mechanism by which Rust guarantees it, the
 > You may have one or the other of these two kinds of borrows, but not both at
 > the same time:
 > 
-> * 0 to N references (`&T`) to a resource.
+> * one or more references (`&T`) to a resource.
 > * exactly one mutable reference (`&mut T`)
 
 [ownership]: ownership.html

branches/try/src/libcollections/vec.rs

@@ -647,7 +647,7 @@ impl<T> Vec<T> {
             // zero-size types consume no memory, so we can't rely on the
             // address space running out
             self.len = self.len.checked_add(1).expect("length overflow");
-            mem::forget(value);
+            unsafe { mem::forget(value); }
             return
         }
 
@@ -994,7 +994,7 @@ impl<T> Vec<T> {
                 num_u: 0,
                 marker: PhantomData,
             };
-            mem::forget(vec);
+            unsafe { mem::forget(vec); }
 
             while pv.num_t != 0 {
                 unsafe {

branches/try/src/libcore/intrinsics.rs

@@ -232,6 +232,10 @@ extern "rust-intrinsic" {
     pub fn uninit<T>() -> T;
 
     /// Moves a value out of scope without running drop glue.
+    ///
+    /// `forget` is unsafe because the caller is responsible for
+    /// ensuring the argument is deallocated already.
+    #[stable(feature = "rust1", since = "1.0.0")]
     pub fn forget<T>(_: T) -> ();
 
     /// Unsafely transforms a value of one type into a value of another type.

branches/try/src/libcore/mem.rs

@@ -22,54 +22,15 @@ use ptr;
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use intrinsics::transmute;
 
-/// Leaks a value into the void, consuming ownership and never running its
-/// destructor.
+/// Moves a thing into the void.
 ///
-/// This function will take ownership of its argument, but is distinct from the
-/// `mem::drop` function in that it **does not run the destructor**, leaking the
-/// value and any resources that it owns.
+/// The forget function will take ownership of the provided value but neglect
+/// to run any required cleanup or memory management operations on it.
 ///
-/// # Safety
-///
-/// This function is not marked as `unsafe` as Rust does not guarantee that the
-/// `Drop` implementation for a value will always run. Note, however, that
-/// leaking resources such as memory or I/O objects is likely not desired, so
-/// this function is only recommended for specialized use cases.
-///
-/// The safety of this function implies that when writing `unsafe` code
-/// yourself care must be taken when leveraging a destructor that is required to
-/// run to preserve memory safety. There are known situations where the
-/// destructor may not run (such as if ownership of the object with the
-/// destructor is returned) which must be taken into account.
-///
-/// # Other forms of Leakage
-///
-/// It's important to point out that this function is not the only method by
-/// which a value can be leaked in safe Rust code. Other known sources of
-/// leakage are:
-///
-/// * `Rc` and `Arc` cycles
-/// * `mpsc::{Sender, Receiver}` cycles (they use `Arc` internally)
-/// * Panicking destructors are likely to leak local resources
-///
-/// # Example
-///
-/// ```rust,no_run
-/// use std::mem;
-/// use std::fs::File;
-///
-/// // Leak some heap memory by never deallocating it
-/// let heap_memory = Box::new(3);
-/// mem::forget(heap_memory);
-///
-/// // Leak an I/O object, never closing the file
-/// let file = File::open("foo.txt").unwrap();
-/// mem::forget(file);
-/// ```
+/// This function is the unsafe version of the `drop` function because it does
+/// not run any destructors.
 #[stable(feature = "rust1", since = "1.0.0")]
-pub fn forget<T>(t: T) {
-    unsafe { intrinsics::forget(t) }
-}
+pub use intrinsics::forget;
 
 /// Returns the size of a type in bytes.
 ///

branches/try/src/libstd/fs.rs

@@ -23,7 +23,7 @@ use fmt;
 use ffi::OsString;
 use io::{self, Error, ErrorKind, SeekFrom, Seek, Read, Write};
 use path::{Path, PathBuf};
-use sys::fs as fs_imp;
+use sys::fs2 as fs_imp;
 use sys_common::{AsInnerMut, FromInner, AsInner};
 use vec::Vec;
 

branches/try/src/libstd/net/mod.rs

@@ -15,7 +15,7 @@
 use prelude::v1::*;
 
 use io::{self, Error, ErrorKind};
-use sys_common::net as net_imp;
+use sys_common::net2 as net_imp;
 
 pub use self::ip::{IpAddr, Ipv4Addr, Ipv6Addr, Ipv6MulticastScope};
 pub use self::addr::{SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};

branches/try/src/libstd/net/tcp.rs

@@ -17,7 +17,7 @@ use io::prelude::*;
 use fmt;
 use io;
 use net::{ToSocketAddrs, SocketAddr, Shutdown};
-use sys_common::net as net_imp;
+use sys_common::net2 as net_imp;
 use sys_common::{AsInner, FromInner};
 
 /// A structure which represents a TCP stream between a local socket and a

branches/try/src/libstd/net/udp.rs

@@ -16,7 +16,7 @@ use prelude::v1::*;
 use fmt;
 use io::{self, Error, ErrorKind};
 use net::{ToSocketAddrs, SocketAddr, IpAddr};
-use sys_common::net as net_imp;
+use sys_common::net2 as net_imp;
 use sys_common::{AsInner, FromInner};
 
 /// A User Datagram Protocol socket.

branches/try/src/libstd/os/android/mod.rs

@@ -15,5 +15,5 @@
 pub mod raw;
 
 pub mod fs {
-    pub use sys::fs::MetadataExt;
+    pub use sys::fs2::MetadataExt;
 }

branches/try/src/libstd/os/bitrig/mod.rs

@@ -15,5 +15,5 @@
 pub mod raw;
 
 pub mod fs {
-    pub use sys::fs::MetadataExt;
+    pub use sys::fs2::MetadataExt;
 }

branches/try/src/libstd/os/dragonfly/mod.rs

@@ -15,5 +15,5 @@
 pub mod raw;
 
 pub mod fs {
-    pub use sys::fs::MetadataExt;
+    pub use sys::fs2::MetadataExt;
 }

branches/try/src/libstd/os/freebsd/mod.rs

@@ -15,5 +15,5 @@
 pub mod raw;
 
 pub mod fs {
-    pub use sys::fs::MetadataExt;
+    pub use sys::fs2::MetadataExt;
 }

branches/try/src/libstd/os/ios/mod.rs

@@ -15,5 +15,5 @@
 pub mod raw;
 
 pub mod fs {
-    pub use sys::fs::MetadataExt;
+    pub use sys::fs2::MetadataExt;
 }

branches/try/src/libstd/os/linux/mod.rs

@@ -15,5 +15,5 @@
 pub mod raw;
 
 pub mod fs {
-    pub use sys::fs::MetadataExt;
+    pub use sys::fs2::MetadataExt;
 }

branches/try/src/libstd/os/macos/mod.rs

@@ -15,5 +15,5 @@
 pub mod raw;
 
 pub mod fs {
-    pub use sys::fs::MetadataExt;
+    pub use sys::fs2::MetadataExt;
 }

branches/try/src/libstd/os/nacl/mod.rs

@@ -15,5 +15,5 @@
 pub mod raw;
 
 pub mod fs {
-    pub use sys::fs::MetadataExt;
+    pub use sys::fs2::MetadataExt;
 }

branches/try/src/libstd/os/openbsd/mod.rs

@@ -15,5 +15,5 @@
 pub mod raw;
 
 pub mod fs {
-    pub use sys::fs::MetadataExt;
+    pub use sys::fs2::MetadataExt;
 }

branches/try/src/libstd/process.rs

@@ -21,11 +21,11 @@ use fmt;
 use io::{self, Error, ErrorKind};
 use path;
 use sync::mpsc::{channel, Receiver};
-use sys::pipe::{self, AnonPipe};
-use sys::process::Command as CommandImp;
-use sys::process::Process as ProcessImp;
-use sys::process::ExitStatus as ExitStatusImp;
-use sys::process::Stdio as StdioImp2;
+use sys::pipe2::{self, AnonPipe};
+use sys::process2::Command as CommandImp;
+use sys::process2::Process as ProcessImp;
+use sys::process2::ExitStatus as ExitStatusImp;
+use sys::process2::Stdio as StdioImp2;
 use sys_common::{AsInner, AsInnerMut};
 use thread;
 
@@ -334,7 +334,7 @@ fn setup_io(io: &StdioImp, readable: bool)
         Null => (StdioImp2::None, None),
         Inherit => (StdioImp2::Inherit, None),
         Piped => {
-            let (reader, writer) = try!(pipe::anon_pipe());
+            let (reader, writer) = try!(pipe2::anon_pipe());
             if readable {
                 (StdioImp2::Piped(reader), Some(writer))
             } else {