---

yaml
---
r: 187499
b: refs/heads/try
c: 4a22c33
h: refs/heads/master
i:
  187497: 2c3a62d
  187495: d810355
v: v3

Author: thepowersgang

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: b4c965ee803a4521d8b4575f634e036f93e408f3
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 3a96d6a9818fe2affc98a187fb1065120458cee9
-refs/heads/try: 3c1f61ce63e911698666c7da1bbf21cdc9818a84
+refs/heads/try: 4a22c3368fe4fd570859fbbf03b971f4913a8569
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/src/compiletest/compiletest.rs

@@ -20,6 +20,7 @@
 #![feature(std_misc)]
 #![feature(test)]
 #![feature(unicode)]
+#![feature(env)]
 #![feature(core)]
 
 #![deny(warnings)]

branches/try/src/doc/intro.md

@@ -536,7 +536,7 @@ use std::thread::Thread;
 
 fn main() {
     let numbers = vec![1, 2, 3];
-
+    
     let guards: Vec<_> = (0..3).map(|i| {
         Thread::scoped(move || {
             println!("{}", numbers[i]);
@@ -565,7 +565,7 @@ while retaining safety. The answer is iterators:
 ```{rust}
 let vec = vec![1, 2, 3];
 
-for x in &vec {
+for x in vec.iter() {
     println!("{}", x);
 }
 ```

branches/try/src/doc/reference.md

@@ -3765,9 +3765,9 @@ An example of creating and calling a closure:
 ```rust
 let captured_var = 10;
 
-let closure_no_args = || println!("captured_var={}", captured_var);
+let closure_no_args = |&:| println!("captured_var={}", captured_var);
 
-let closure_args = |arg: i32| -> i32 {
+let closure_args = |&: arg: i32| -> i32 {
   println!("captured_var={}, arg={}", captured_var, arg);
   arg // Note lack of semicolon after 'arg'
 };

branches/try/src/doc/trpl/installing-rust.md

@@ -70,10 +70,10 @@ If you've got Rust installed, you can open up a shell, and type this:
 $ rustc --version
 ```
 
-You should see the version number, commit hash, commit date and build date:
+You should see some output that looks something like this:
 
 ```bash
-rustc 1.0.0-nightly (f11f3e7ba 2015-01-04) (built 2015-01-06)
+rustc 1.0.0-nightly (f11f3e7ba 2015-01-04 20:02:14 +0000)
 ```
 
 If you did, Rust has been installed successfully! Congrats!

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

@@ -71,8 +71,8 @@ extern crate rustc;
 use syntax::codemap::Span;
 use syntax::parse::token;
 use syntax::ast::{TokenTree, TtToken};
-use syntax::ext::base::{ExtCtxt, MacResult, DummyResult, MacEager};
-use syntax::ext::build::AstBuilder;  // trait for expr_usize
+use syntax::ext::base::{ExtCtxt, MacResult, DummyResult, MacExpr};
+use syntax::ext::build::AstBuilder;  // trait for expr_uint
 use rustc::plugin::Registry;
 
 fn expand_rn(cx: &mut ExtCtxt, sp: Span, args: &[TokenTree])
@@ -107,7 +107,7 @@ fn expand_rn(cx: &mut ExtCtxt, sp: Span, args: &[TokenTree])
         }
     }
 
-    MacEager::expr(cx.expr_usize(sp, total))
+    MacExpr::new(cx.expr_uint(sp, total))
 }
 
 #[plugin_registrar]
@@ -183,7 +183,7 @@ with
 [`syntax::print::pprust::*_to_string`](http://doc.rust-lang.org/syntax/print/pprust/index.html#functions).
 
 The example above produced an integer literal using
-[`AstBuilder::expr_usize`](../syntax/ext/build/trait.AstBuilder.html#tymethod.expr_usize).
+[`AstBuilder::expr_uint`](../syntax/ext/build/trait.AstBuilder.html#tymethod.expr_uint).
 As an alternative to the `AstBuilder` trait, `libsyntax` provides a set of
 [quasiquote macros](../syntax/ext/quote/index.html).  They are undocumented and
 very rough around the edges.  However, the implementation may be a good

branches/try/src/libcore/fmt/mod.rs

@@ -700,7 +700,7 @@ impl Display for char {
 impl<T> Pointer for *const T {
     fn fmt(&self, f: &mut Formatter) -> Result {
         f.flags |= 1 << (FlagV1::Alternate as u32);
-        let ret = LowerHex::fmt(&(*self as u32), f);
+        let ret = LowerHex::fmt(&(*self as usize), f);
         f.flags &= !(1 << (FlagV1::Alternate as u32));
         ret
     }

branches/try/src/libcore/iter.rs

@@ -68,7 +68,7 @@ use num::{ToPrimitive, Int};
 use ops::{Add, Deref, FnMut};
 use option::Option;
 use option::Option::{Some, None};
-use marker::Sized;
+use marker::{Send, Sized, Sync};
 use usize;
 
 /// An interface for dealing with "external iterators". These types of iterators
@@ -1783,6 +1783,10 @@ pub struct Peekable<I: Iterator> {
     peeked: Option<I::Item>,
 }
 
+// FIXME: after #22828 being fixed, the following unsafe impl should be removed
+unsafe impl<I: Iterator> Sync for Peekable<I> where I: Sync, I::Item: Sync {}
+unsafe impl<I: Iterator> Send for Peekable<I> where I: Send, I::Item: Send {}
+
 impl<I: Iterator + Clone> Clone for Peekable<I> where I::Item: Clone {
     fn clone(&self) -> Peekable<I> {
         Peekable {
@@ -2870,10 +2874,10 @@ pub mod order {
     use super::Iterator;
 
     /// Compare `a` and `b` for equality using `Eq`
-    pub fn equals<A, L, R>(mut a: L, mut b: R) -> bool where
+    pub fn equals<A, T, S>(mut a: T, mut b: S) -> bool where
         A: Eq,
-        L: Iterator<Item=A>,
-        R: Iterator<Item=A>,
+        T: Iterator<Item=A>,
+        S: Iterator<Item=A>,
     {
         loop {
             match (a.next(), b.next()) {
@@ -2885,10 +2889,10 @@ pub mod order {
     }
 
     /// Order `a` and `b` lexicographically using `Ord`
-    pub fn cmp<A, L, R>(mut a: L, mut b: R) -> cmp::Ordering where
+    pub fn cmp<A, T, S>(mut a: T, mut b: S) -> cmp::Ordering where
         A: Ord,
-        L: Iterator<Item=A>,
-        R: Iterator<Item=A>,
+        T: Iterator<Item=A>,
+        S: Iterator<Item=A>,
     {
         loop {
             match (a.next(), b.next()) {
@@ -2904,8 +2908,10 @@ pub mod order {
     }
 
     /// Order `a` and `b` lexicographically using `PartialOrd`
-    pub fn partial_cmp<L: Iterator, R: Iterator>(mut a: L, mut b: R) -> Option<cmp::Ordering> where
-        L::Item: PartialOrd<R::Item>
+    pub fn partial_cmp<A, T, S>(mut a: T, mut b: S) -> Option<cmp::Ordering> where
+        A: PartialOrd,
+        T: Iterator<Item=A>,
+        S: Iterator<Item=A>,
     {
         loop {
             match (a.next(), b.next()) {
@@ -2921,8 +2927,10 @@ pub mod order {
     }
 
     /// Compare `a` and `b` for equality (Using partial equality, `PartialEq`)
-    pub fn eq<L: Iterator, R: Iterator>(mut a: L, mut b: R) -> bool where
-        L::Item: PartialEq<R::Item>,
+    pub fn eq<A, B, L, R>(mut a: L, mut b: R) -> bool where
+        A: PartialEq<B>,
+        L: Iterator<Item=A>,
+        R: Iterator<Item=B>,
     {
         loop {
             match (a.next(), b.next()) {
@@ -2934,8 +2942,10 @@ pub mod order {
     }
 
     /// Compare `a` and `b` for nonequality (Using partial equality, `PartialEq`)
-    pub fn ne<L: Iterator, R: Iterator>(mut a: L, mut b: R) -> bool where
-        L::Item: PartialEq<R::Item>,
+    pub fn ne<A, B, L, R>(mut a: L, mut b: R) -> bool where
+        A: PartialEq<B>,
+        L: Iterator<Item=A>,
+        R: Iterator<Item=B>,
     {
         loop {
             match (a.next(), b.next()) {
@@ -2947,8 +2957,10 @@ pub mod order {
     }
 
     /// Return `a` < `b` lexicographically (Using partial order, `PartialOrd`)
-    pub fn lt<R: Iterator, L: Iterator>(mut a: L, mut b: R) -> bool where
-        L::Item: PartialOrd<R::Item>,
+    pub fn lt<A, T, S>(mut a: T, mut b: S) -> bool where
+        A: PartialOrd,
+        T: Iterator<Item=A>,
+        S: Iterator<Item=A>,
     {
         loop {
             match (a.next(), b.next()) {
@@ -2961,8 +2973,10 @@ pub mod order {
     }
 
     /// Return `a` <= `b` lexicographically (Using partial order, `PartialOrd`)
-    pub fn le<L: Iterator, R: Iterator>(mut a: L, mut b: R) -> bool where
-        L::Item: PartialOrd<R::Item>,
+    pub fn le<A, T, S>(mut a: T, mut b: S) -> bool where
+        A: PartialOrd,
+        T: Iterator<Item=A>,
+        S: Iterator<Item=A>,
     {
         loop {
             match (a.next(), b.next()) {
@@ -2975,8 +2989,10 @@ pub mod order {
     }
 
     /// Return `a` > `b` lexicographically (Using partial order, `PartialOrd`)
-    pub fn gt<L: Iterator, R: Iterator>(mut a: L, mut b: R) -> bool where
-        L::Item: PartialOrd<R::Item>,
+    pub fn gt<A, T, S>(mut a: T, mut b: S) -> bool where
+        A: PartialOrd,
+        T: Iterator<Item=A>,
+        S: Iterator<Item=A>,
     {
         loop {
             match (a.next(), b.next()) {
@@ -2989,8 +3005,10 @@ pub mod order {
     }
 
     /// Return `a` >= `b` lexicographically (Using partial order, `PartialOrd`)
-    pub fn ge<L: Iterator, R: Iterator>(mut a: L, mut b: R) -> bool where
-        L::Item: PartialOrd<R::Item>,
+    pub fn ge<A, T, S>(mut a: T, mut b: S) -> bool where
+        A: PartialOrd,
+        T: Iterator<Item=A>,
+        S: Iterator<Item=A>,
     {
         loop {
             match (a.next(), b.next()) {

branches/try/src/liblog/lib.rs

@@ -174,6 +174,7 @@
 #![feature(core)]
 #![feature(old_io)]
 #![feature(std_misc)]
+#![feature(env)]
 
 use std::boxed;
 use std::cell::RefCell;

branches/try/src/librustc/lib.rs

@@ -31,6 +31,7 @@
 #![feature(int_uint)]
 #![feature(old_io)]
 #![feature(libc)]
+#![feature(env)]
 #![feature(old_path)]
 #![feature(quote)]
 #![feature(rustc_diagnostic_macros)]

branches/try/src/librustc/middle/const_eval.rs

@@ -257,7 +257,7 @@ pub fn eval_const_expr_partial<'tcx>(tcx: &ty::ctxt<'tcx>,
             }
           }
           (Ok(const_int(a)), Ok(const_int(b))) => {
-            let is_a_min_value = || {
+            let is_a_min_value = |&:| {
                 let int_ty = match ty::expr_ty_opt(tcx, e).map(|ty| &ty.sty) {
                     Some(&ty::ty_int(int_ty)) => int_ty,
                     _ => return false

branches/try/src/librustc_back/lib.rs

@@ -40,6 +40,7 @@
 #![feature(old_path)]
 #![feature(rustc_private)]
 #![feature(staged_api)]
+#![feature(env)]
 #![feature(path)]
 
 extern crate syntax;

branches/try/src/librustc_driver/lib.rs

@@ -26,6 +26,7 @@
 #![feature(box_syntax)]
 #![feature(collections)]
 #![feature(core)]
+#![feature(env)]
 #![feature(int_uint)]
 #![feature(old_io)]
 #![feature(libc)]
@@ -37,7 +38,6 @@
 #![feature(unsafe_destructor)]
 #![feature(staged_api)]
 #![feature(unicode)]
-#![feature(exit_status)]
 
 extern crate arena;
 extern crate flate;

branches/try/src/librustc_trans/lib.rs

@@ -30,6 +30,7 @@
 #![feature(core)]
 #![feature(int_uint)]
 #![feature(old_io)]
+#![feature(env)]
 #![feature(libc)]
 #![feature(old_path)]
 #![feature(quote)]

branches/try/src/librustc_trans/trans/base.rs

@@ -433,13 +433,13 @@ pub fn set_inline_hint(f: ValueRef) {
 }
 
 pub fn set_llvm_fn_attrs(ccx: &CrateContext, attrs: &[ast::Attribute], llfn: ValueRef) {
-    use syntax::attr::{find_inline_attr, InlineAttr};
+    use syntax::attr::*;
     // Set the inline hint if there is one
     match find_inline_attr(Some(ccx.sess().diagnostic()), attrs) {
-        InlineAttr::Hint   => set_inline_hint(llfn),
-        InlineAttr::Always => set_always_inline(llfn),
-        InlineAttr::Never  => set_no_inline(llfn),
-        InlineAttr::None   => { /* fallthrough */ }
+        InlineHint   => set_inline_hint(llfn),
+        InlineAlways => set_always_inline(llfn),
+        InlineNever  => set_no_inline(llfn),
+        InlineNone   => { /* fallthrough */ }
     }
 
     for attr in attrs {

branches/try/src/librustc_typeck/check/dropck.rs

@@ -45,7 +45,7 @@ fn iterate_over_potentially_unsafe_regions_in_type<'a, 'tcx>(
     scope: region::CodeExtent,
     depth: uint)
 {
-    let origin = || infer::SubregionOrigin::SafeDestructor(span);
+    let origin = |&:| infer::SubregionOrigin::SafeDestructor(span);
     let mut walker = ty_root.walk();
     let opt_phantom_data_def_id = rcx.tcx().lang_items.phantom_data();
 

branches/try/src/librustdoc/lib.rs

@@ -22,7 +22,7 @@
 #![feature(box_syntax)]
 #![feature(collections)]
 #![feature(core)]
-#![feature(exit_status)]
+#![feature(env)]
 #![feature(int_uint)]
 #![feature(old_io)]
 #![feature(libc)]