---

yaml
---
r: 152928
b: refs/heads/try2
c: 05e3248
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: b47f2226a25654c5b781d27a91f2fa5274b3a347
+refs/heads/try2: 05e3248a7974f55b64f75a2483b37ff8c001a4ff
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/guide-macros.md

@@ -355,7 +355,6 @@ macro_rules! biased_match_rec (
             _ => { $err }
         }
     );
-    // Produce the requested values
     ( binds $( $bind_res:ident ),* ) => ( ($( $bind_res ),*) )
 )
 
@@ -365,7 +364,7 @@ macro_rules! biased_match (
     ( $( ($e:expr) ~ ($p:pat) else $err:stmt ; )*
       binds $bind_res:ident
     ) => (
-        let $bind_res = biased_match_rec!(
+        let ( $( $bind_res ),* ) = biased_match_rec!(
             $( ($e) ~ ($p) else $err ; )*
             binds $bind_res
         );

branches/try2/src/liballoc/owned.rs

@@ -16,6 +16,7 @@ use core::cmp::{PartialEq, PartialOrd, Eq, Ord, Ordering};
 use core::default::Default;
 use core::fmt;
 use core::intrinsics;
+use core::kinds::Send;
 use core::mem;
 use core::raw::TraitObject;
 use core::result::{Ok, Err, Result};
@@ -106,6 +107,34 @@ impl AnyOwnExt for Box<Any> {
     }
 }
 
+/// Extension methods for an owning `Any+Send` trait object
+pub trait AnySendOwnExt {
+    /// Returns the boxed value if it is of type `T`, or
+    /// `Err(Self)` if it isn't.
+    fn move_send<T: 'static>(self) -> Result<Box<T>, Self>;
+}
+
+impl AnySendOwnExt for Box<Any+Send> {
+    #[inline]
+    fn move_send<T: 'static>(self) -> Result<Box<T>, Box<Any+Send>> {
+        if self.is::<T>() {
+            unsafe {
+                // Get the raw representation of the trait object
+                let to: TraitObject =
+                    *mem::transmute::<&Box<Any+Send>, &TraitObject>(&self);
+
+                // Prevent destructor on self being run
+                intrinsics::forget(self);
+
+                // Extract the data pointer
+                Ok(mem::transmute(to.data))
+            }
+        } else {
+            Err(self)
+        }
+    }
+}
+
 impl<T: fmt::Show> fmt::Show for Box<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         (**self).fmt(f)

branches/try2/src/libcollections/vec.rs

@@ -956,17 +956,14 @@ impl<T> Vec<T> {
     ///
     /// # Failure
     ///
-    /// Fails if `index` is not between `0` and the vector's length (both
-    /// bounds inclusive).
+    /// Fails if `index` is out of bounds of the vector.
     ///
     /// # Example
     ///
     /// ```rust
     /// let mut vec = vec!(1i, 2, 3);
     /// vec.insert(1, 4);
     /// assert_eq!(vec, vec!(1, 4, 2, 3));
-    /// vec.insert(4, 5);
-    /// assert_eq!(vec, vec!(1, 4, 2, 3, 5));
     /// ```
     pub fn insert(&mut self, index: uint, element: T) {
         let len = self.len();

branches/try2/src/libcore/iter.rs

@@ -135,7 +135,8 @@ pub trait Iterator<A> {
     /// let a = [0i];
     /// let b = [1i];
     /// let mut it = a.iter().zip(b.iter());
-    /// assert_eq!(it.next().unwrap(), (&0, &1));
+    /// let (x0, x1) = (0i, 1i);
+    /// assert_eq!(it.next().unwrap(), (&x0, &x1));
     /// assert!(it.next().is_none());
     /// ```
     #[inline]
@@ -202,8 +203,9 @@ pub trait Iterator<A> {
     /// ```rust
     /// let a = [100i, 200];
     /// let mut it = a.iter().enumerate();
-    /// assert_eq!(it.next().unwrap(), (0, &100));
-    /// assert_eq!(it.next().unwrap(), (1, &200));
+    /// let (x100, x200) = (100i, 200i);
+    /// assert_eq!(it.next().unwrap(), (0, &x100));
+    /// assert_eq!(it.next().unwrap(), (1, &x200));
     /// assert!(it.next().is_none());
     /// ```
     #[inline]
@@ -220,11 +222,11 @@ pub trait Iterator<A> {
     /// ```rust
     /// let xs = [100i, 200, 300];
     /// let mut it = xs.iter().map(|x| *x).peekable();
-    /// assert_eq!(it.peek().unwrap(), &100);
+    /// assert_eq!(*it.peek().unwrap(), 100);
     /// assert_eq!(it.next().unwrap(), 100);
     /// assert_eq!(it.next().unwrap(), 200);
-    /// assert_eq!(it.peek().unwrap(), &300);
-    /// assert_eq!(it.peek().unwrap(), &300);
+    /// assert_eq!(*it.peek().unwrap(), 300);
+    /// assert_eq!(*it.peek().unwrap(), 300);
     /// assert_eq!(it.next().unwrap(), 300);
     /// assert!(it.peek().is_none());
     /// assert!(it.next().is_none());

branches/try2/src/librustc/middle/typeck/check/vtable.rs

@@ -352,17 +352,15 @@ fn search_for_vtable(vcx: &VtableContext,
         // the next impl.
         //
         // FIXME: document a bit more what this means
-        //
-        // FIXME(#5781) this should be mk_eqty not mk_subty
         let TypeAndSubsts {
             substs: substs,
             ty: for_ty
         } = impl_self_ty(vcx, span, impl_did);
-        match infer::mk_subty(vcx.infcx,
-                              false,
-                              infer::RelateSelfType(span),
-                              ty,
-                              for_ty) {
+        match infer::mk_eqty(vcx.infcx,
+                             false,
+                             infer::RelateSelfType(span),
+                             ty,
+                             for_ty) {
             Err(_) => continue,
             Ok(()) => ()
         }

branches/try2/src/librustc/middle/typeck/infer/combine.rs

@@ -84,41 +84,25 @@ pub trait Combine {
     fn tys(&self, a: ty::t, b: ty::t) -> cres<ty::t>;
 
     fn tps(&self,
-           space: subst::ParamSpace,
+           _: subst::ParamSpace,
            as_: &[ty::t],
            bs: &[ty::t])
-           -> cres<Vec<ty::t>>
-    {
-        // FIXME(#5781) -- In general, we treat variance a bit wrong
-        // here. For historical reasons, we treat Self as
-        // contravariant and other tps as invariant. Both are wrong:
-        // Self may or may not be contravariant, and other tps do not
-        // need to be invariant.
+           -> cres<Vec<ty::t>> {
+        // FIXME -- In general, we treat variance a bit wrong
+        // here. For historical reasons, we treat tps and Self
+        // as invariant. This is overly conservative.
 
         if as_.len() != bs.len() {
             return Err(ty::terr_ty_param_size(expected_found(self,
                                                              as_.len(),
                                                              bs.len())));
         }
 
-        match space {
-            subst::SelfSpace => {
-                result::fold(as_
-                             .iter()
-                             .zip(bs.iter())
-                             .map(|(a, b)| self.contratys(*a, *b)),
-                             Vec::new(),
-                             |mut v, a| { v.push(a); v })
-            }
-
-            subst::TypeSpace | subst::FnSpace => {
-                try!(result::fold_(as_
-                                  .iter()
-                                  .zip(bs.iter())
-                                  .map(|(a, b)| eq_tys(self, *a, *b))));
-                Ok(Vec::from_slice(as_))
-            }
-        }
+        try!(result::fold_(as_
+                          .iter()
+                          .zip(bs.iter())
+                          .map(|(a, b)| eq_tys(self, *a, *b))));
+        Ok(Vec::from_slice(as_))
     }
 
     fn substs(&self,

branches/try2/src/librustc/middle/typeck/variance.rs

@@ -78,8 +78,8 @@ receiver position from being called via an object.)
 #### Trait variance and vtable resolution
 
 But traits aren't only used with objects. They're also used when
-deciding whether a given impl satisfies a given trait bound (or should
-be -- FIXME #5781). To set the scene here, imagine I had a function:
+deciding whether a given impl satisfies a given trait bound. To set the
+scene here, imagine I had a function:
 
     fn convertAll<A,T:ConvertTo<A>>(v: &[T]) {
         ...

branches/try2/src/librustdoc/test.rs

@@ -140,7 +140,14 @@ fn runtest(test: &str, cratename: &str, libs: HashSet<Path>, should_fail: bool,
     let old = io::stdio::set_stderr(box w1);
     spawn(proc() {
         let mut p = io::ChanReader::new(rx);
-        let mut err = old.unwrap_or(box io::stderr() as Box<Writer + Send>);
+        let mut err = match old {
+            Some(old) => {
+                // Chop off the `Send` bound.
+                let old: Box<Writer> = old;
+                old
+            }
+            None => box io::stderr() as Box<Writer>,
+        };
         io::util::copy(&mut p, &mut err).unwrap();
     });
     let emitter = diagnostic::EmitterWriter::new(box w2);

branches/try2/src/libstd/io/comm_adapters.rs

@@ -183,7 +183,10 @@ mod test {
         writer.write_be_u32(42).unwrap();
 
         let wanted = vec![0u8, 0u8, 0u8, 42u8];
-        let got = task::try(proc() { rx.recv() }).unwrap();
+        let got = match task::try(proc() { rx.recv() }) {
+            Ok(got) => got,
+            Err(_) => fail!(),
+        };
         assert_eq!(wanted, got);
 
         match writer.write_u8(1) {

branches/try2/src/libstd/task.rs

@@ -630,9 +630,11 @@ mod test {
         let mut reader = ChanReader::new(rx);
         let stdout = ChanWriter::new(tx);
 
-        TaskBuilder::new().stdout(box stdout as Box<Writer + Send>).try(proc() {
-            print!("Hello, world!");
-        }).unwrap();
+        let r = TaskBuilder::new().stdout(box stdout as Box<Writer + Send>)
+                                  .try(proc() {
+                print!("Hello, world!");
+            });
+        assert!(r.is_ok());
 
         let output = reader.read_to_str().unwrap();
         assert_eq!(output, "Hello, world!".to_string());

branches/try2/src/libsyntax/ast.rs

@@ -401,7 +401,6 @@ pub enum Decl_ {
     DeclItem(Gc<Item>),
 }
 
-/// represents one arm of a 'match'
 #[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
 pub struct Arm {
     pub attrs: Vec<Attribute>,

branches/try2/src/libsyntax/diagnostic.rs

@@ -18,6 +18,7 @@ use std::fmt;
 use std::io;
 use std::iter::range;
 use std::string::String;
+use term::WriterWrapper;
 use term;
 
 // maximum number of lines we will print for each error; arbitrary.
@@ -281,7 +282,7 @@ pub struct EmitterWriter {
 }
 
 enum Destination {
-    Terminal(Box<term::Terminal<Box<Writer + Send>> + Send>),
+    Terminal(Box<term::Terminal<WriterWrapper> + Send>),
     Raw(Box<Writer + Send>),
 }