---

yaml
---
r: 210425
b: refs/heads/try
c: dd59b1f
h: refs/heads/master
i:
  210423: 7d93279
v: v3

Author: alexcrichton

[refs]

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

branches/try/src/libcollections/vec.rs

@@ -67,7 +67,7 @@ use core::intrinsics::assume;
 use core::iter::{repeat, FromIterator};
 use core::marker::PhantomData;
 use core::mem;
-use core::ops::{Index, IndexMut, Deref};
+use core::ops::{Index, IndexMut, Deref, Add};
 use core::ops;
 use core::ptr;
 use core::ptr::Unique;
@@ -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");
-            unsafe { mem::forget(value); }
+            mem::forget(value);
             return
         }
 
@@ -994,7 +994,7 @@ impl<T> Vec<T> {
                 num_u: 0,
                 marker: PhantomData,
             };
-            unsafe { mem::forget(vec); }
+            mem::forget(vec);
 
             while pv.num_t != 0 {
                 unsafe {
@@ -1622,6 +1622,17 @@ impl<T: Ord> Ord for Vec<T> {
     }
 }
 
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<'a, T: Clone> Add<&'a [T]> for Vec<T> {
+    type Output = Vec<T>;
+
+    #[inline]
+    fn add(mut self, rhs: &[T]) -> Vec<T> {
+        self.push_all(rhs);
+        self
+    }
+}
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> Drop for Vec<T> {
     fn drop(&mut self) {

branches/try/src/libcore/intrinsics.rs

@@ -232,10 +232,6 @@ 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,15 +22,54 @@ use ptr;
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use intrinsics::transmute;
 
-/// Moves a thing into the void.
+/// Leaks a value into the void, consuming ownership and never running its
+/// destructor.
 ///
-/// The forget function will take ownership of the provided value but neglect
-/// to run any required cleanup or memory management operations on it.
+/// 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.
 ///
-/// This function is the unsafe version of the `drop` function because it does
-/// not run any destructors.
+/// # 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);
+/// ```
 #[stable(feature = "rust1", since = "1.0.0")]
-pub use intrinsics::forget;
+pub fn forget<T>(t: T) {
+    unsafe { intrinsics::forget(t) }
+}
 
 /// Returns the size of a type in bytes.
 ///

branches/try/src/libcore/slice.rs

@@ -631,14 +631,8 @@ fn size_from_ptr<T>(_: *const T) -> usize {
 }
 
 
-// Use macros to be generic over const/mut
-//
-// They require non-negative `$by` because otherwise the expression
-// `(ptr as usize + $by)` would interpret `-1` as `usize::MAX` (and
-// thus trigger a panic when overflow checks are on).
-
-// Use this to do `$ptr + $by`, where `$by` is non-negative.
-macro_rules! slice_add_offset {
+// Use macro to be generic over const/mut
+macro_rules! slice_offset {
     ($ptr:expr, $by:expr) => {{
         let ptr = $ptr;
         if size_from_ptr(ptr) == 0 {
@@ -649,18 +643,6 @@ macro_rules! slice_add_offset {
     }};
 }
 
-// Use this to do `$ptr - $by`, where `$by` is non-negative.
-macro_rules! slice_sub_offset {
-    ($ptr:expr, $by:expr) => {{
-        let ptr = $ptr;
-        if size_from_ptr(ptr) == 0 {
-            transmute(ptr as usize - $by)
-        } else {
-            ptr.offset(-$by)
-        }
-    }};
-}
-
 macro_rules! slice_ref {
     ($ptr:expr) => {{
         let ptr = $ptr;
@@ -690,7 +672,7 @@ macro_rules! iterator {
                         None
                     } else {
                         let old = self.ptr;
-                        self.ptr = slice_add_offset!(self.ptr, 1);
+                        self.ptr = slice_offset!(self.ptr, 1);
                         Some(slice_ref!(old))
                     }
                 }
@@ -732,7 +714,7 @@ macro_rules! iterator {
                     if self.end == self.ptr {
                         None
                     } else {
-                        self.end = slice_sub_offset!(self.end, 1);
+                        self.end = slice_offset!(self.end, -1);
                         Some(slice_ref!(self.end))
                     }
                 }
@@ -794,7 +776,7 @@ impl<'a, T> Iter<'a, T> {
     fn iter_nth(&mut self, n: usize) -> Option<&'a T> {
         match self.as_slice().get(n) {
             Some(elem_ref) => unsafe {
-                self.ptr = slice_add_offset!(elem_ref as *const _, 1);
+                self.ptr = slice_offset!(elem_ref as *const _, 1);
                 Some(slice_ref!(elem_ref))
             },
             None => {
@@ -867,7 +849,7 @@ impl<'a, T> IterMut<'a, T> {
     fn iter_nth(&mut self, n: usize) -> Option<&'a mut T> {
         match make_mut_slice!(T => &'a mut [T]: self.ptr, self.end).get_mut(n) {
             Some(elem_ref) => unsafe {
-                self.ptr = slice_add_offset!(elem_ref as *mut _, 1);
+                self.ptr = slice_offset!(elem_ref as *mut _, 1);
                 Some(slice_ref!(elem_ref))
             },
             None => {

branches/try/src/librustc/middle/traits/error_reporting.rs

@@ -56,12 +56,7 @@ pub fn report_projection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
 {
     let predicate =
         infcx.resolve_type_vars_if_possible(&obligation.predicate);
-    // The ty_err created by normalize_to_error can end up being unified
-    // into all obligations: for example, if our obligation is something
-    // like `$X = <() as Foo<$X>>::Out` and () does not implement Foo<_>,
-    // then $X will be unified with ty_err, but the error still needs to be
-    // reported.
-    if !infcx.tcx.sess.has_errors() || !predicate.references_error() {
+    if !predicate.references_error() {
         span_err!(infcx.tcx.sess, obligation.cause.span, E0271,
                 "type mismatch resolving `{}`: {}",
                 predicate.user_string(infcx.tcx),
@@ -188,8 +183,7 @@ pub fn report_selection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
                             let trait_predicate =
                                 infcx.resolve_type_vars_if_possible(trait_predicate);
 
-                            if !infcx.tcx.sess.has_errors() ||
-                               !trait_predicate.references_error() {
+                            if !trait_predicate.references_error() {
                                 let trait_ref = trait_predicate.to_poly_trait_ref();
                                 span_err!(infcx.tcx.sess, obligation.cause.span, E0277,
                                         "the trait `{}` is not implemented for the type `{}`",

branches/try/src/librustc/middle/traits/project.rs

@@ -408,10 +408,7 @@ fn opt_normalize_projection_type<'a,'b,'tcx>(
 }
 
 /// in various error cases, we just set ty_err and return an obligation
-/// that, when fulfilled, will lead to an error.
-///
-/// FIXME: the ty_err created here can enter the obligation we create,
-/// leading to error messages involving ty_err.
+/// that, when fulfilled, will lead to an error
 fn normalize_to_error<'a,'tcx>(selcx: &mut SelectionContext<'a,'tcx>,
                                projection_ty: ty::ProjectionTy<'tcx>,
                                cause: ObligationCause<'tcx>,

branches/try/src/librustdoc/html/render.rs

@@ -1460,9 +1460,7 @@ impl<'a> fmt::Display for Item<'a> {
         try!(write!(fmt, "<span class='out-of-band'>"));
         try!(write!(fmt,
         r##"<span id='render-detail'>
-            <a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
-                [<span class='inner'>&#x2212;</span>]
-            </a>
+            <a id="toggle-all-docs" href="#" title="collapse all docs">[&minus;]</a>
         </span>"##));
 
         // Write `src` tag

branches/try/src/librustdoc/html/static/main.css

@@ -581,7 +581,7 @@ pre.rust { position: relative; }
 
 .collapse-toggle > .inner {
     display: inline-block;
-    width: 1.2ch;
+    width: 1ch;
     text-align: center;
 }
 

branches/try/src/librustdoc/html/static/main.js

@@ -806,35 +806,22 @@
         window.location = $('.srclink').attr('href');
     }
 
-    function labelForToggleButton(sectionIsCollapsed) {
-        if (sectionIsCollapsed) {
-            // button will expand the section
-            return "+";
-        } else {
-            // button will collapse the section
-            // note that this text is also set in the HTML template in render.rs
-            return "\u2212"; // "\u2212" is '−' minus sign
-        }
-    }
-
     $("#toggle-all-docs").on("click", function() {
         var toggle = $("#toggle-all-docs");
-        if (toggle.hasClass("will-expand")) {
-            toggle.removeClass("will-expand");
-            toggle.children(".inner").text(labelForToggleButton(false));
-            toggle.attr("title", "collapse all docs");
-            $(".docblock").show();
-            $(".toggle-label").hide();
-            $(".toggle-wrapper").removeClass("collapsed");
-            $(".collapse-toggle").children(".inner").text(labelForToggleButton(false));
-        } else {
-            toggle.addClass("will-expand");
-            toggle.children(".inner").text(labelForToggleButton(true));
+        if (toggle.html() == "[−]") {
+            toggle.html("[+]");
             toggle.attr("title", "expand all docs");
             $(".docblock").hide();
             $(".toggle-label").show();
             $(".toggle-wrapper").addClass("collapsed");
-            $(".collapse-toggle").children(".inner").text(labelForToggleButton(true));
+            $(".collapse-toggle").children(".inner").html("+");
+        } else {
+            toggle.html("[−]");
+            toggle.attr("title", "collapse all docs");
+            $(".docblock").show();
+            $(".toggle-label").hide();
+            $(".toggle-wrapper").removeClass("collapsed");
+            $(".collapse-toggle").children(".inner").html("−");
         }
     });
 
@@ -848,21 +835,20 @@
             if (relatedDoc.is(":visible")) {
                 relatedDoc.slideUp({duration:'fast', easing:'linear'});
                 toggle.parent(".toggle-wrapper").addClass("collapsed");
-                toggle.children(".inner").text(labelForToggleButton(true));
+                toggle.children(".inner").html("+");
                 toggle.children(".toggle-label").fadeIn();
             } else {
                 relatedDoc.slideDown({duration:'fast', easing:'linear'});
                 toggle.parent(".toggle-wrapper").removeClass("collapsed");
-                toggle.children(".inner").text(labelForToggleButton(false));
+                toggle.children(".inner").html("−");
                 toggle.children(".toggle-label").hide();
             }
         }
     });
 
     $(function() {
         var toggle = $("<a/>", {'href': 'javascript:void(0)', 'class': 'collapse-toggle'})
-            .html("[<span class='inner'></span>]");
-        toggle.children(".inner").text(labelForToggleButton(false));
+            .html("[<span class='inner'>&minus;</span>]");
 
         $(".method").each(function() {
             if ($(this).next().is(".docblock") ||

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;
 }