---

yaml
---
r: 160190
b: refs/heads/snap-stage3
c: e09d986
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: bfaa7bcab3459907014c31d3bf980f65ccd14b08
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 2293a04b4936a11fc3e09f3df8a8ab591e034f29
+refs/heads/snap-stage3: e09d98603e608c9e47d4c89f7b4dca87a4b56da3
 refs/heads/try: 225de0d60f8ca8dcc62ab2fd8818ebbda4b58cfe
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/mk/crates.mk

@@ -53,7 +53,7 @@ TARGET_CRATES := libc std green native flate arena term \
                  serialize sync getopts collections test time rand \
                  log regex graphviz core rbml alloc rustrt \
                  unicode
-HOST_CRATES := syntax rustc rustdoc regex_macros fmt_macros \
+HOST_CRATES := syntax rustc rustc_trans rustdoc regex_macros fmt_macros \
 	       rustc_llvm rustc_back
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
@@ -69,11 +69,12 @@ DEPS_graphviz := std
 DEPS_green := std native:context_switch
 DEPS_native := std
 DEPS_syntax := std term serialize log fmt_macros arena libc
+DEPS_rustc_trans := rustc rustc_back rustc_llvm libc
 DEPS_rustc := syntax flate arena serialize getopts rbml \
               time log graphviz rustc_llvm rustc_back
 DEPS_rustc_llvm := native:rustllvm libc std
 DEPS_rustc_back := std syntax rustc_llvm flate log libc
-DEPS_rustdoc := rustc native:hoedown serialize getopts \
+DEPS_rustdoc := rustc rustc_trans native:hoedown serialize getopts \
                 test time
 DEPS_flate := std native:miniz
 DEPS_arena := std
@@ -96,7 +97,7 @@ DEPS_fmt_macros = std
 
 TOOL_DEPS_compiletest := test getopts native
 TOOL_DEPS_rustdoc := rustdoc native
-TOOL_DEPS_rustc := rustc native
+TOOL_DEPS_rustc := rustc_trans native
 TOOL_SOURCE_compiletest := $(S)src/compiletest/compiletest.rs
 TOOL_SOURCE_rustdoc := $(S)src/driver/driver.rs
 TOOL_SOURCE_rustc := $(S)src/driver/driver.rs
@@ -112,8 +113,8 @@ ONLY_RLIB_unicode := 1
 # You should not need to edit below this line
 ################################################################################
 
-DOC_CRATES := $(filter-out rustc, $(filter-out syntax, $(CRATES)))
-COMPILER_DOC_CRATES := rustc syntax
+DOC_CRATES := $(filter-out rustc, $(filter-out rustc_trans, $(filter-out syntax, $(CRATES))))
+COMPILER_DOC_CRATES := rustc rustc_trans syntax
 
 # This macro creates some simple definitions for each crate being built, just
 # some munging of all of the parameters above.

branches/snap-stage3/src/doc/reference.md

@@ -2513,11 +2513,6 @@ The currently implemented features of the reference compiler are:
                closure as `once` is unlikely to be supported going forward. So
                they are hidden behind this feature until they are to be removed.
 
-* `overloaded_calls` - Allow implementing the `Fn*` family of traits on user
-                       types, allowing overloading the call operator (`()`).
-                       This feature may still undergo changes before being
-                       stabilized.
-
 * `phase` - Usage of the `#[phase]` attribute allows loading compiler plugins
             for custom lints or syntax extensions. The implementation is
             considered unwholesome and in need of overhaul, and it is not clear
@@ -2560,11 +2555,8 @@ The currently implemented features of the reference compiler are:
 * `trace_macros` - Allows use of the `trace_macros` macro, which is a nasty
                    hack that will certainly be removed.
 
-* `unboxed_closure_sugar` - Allows using `|Foo| -> Bar` as a trait bound
-                            meaning one of the `Fn` traits. Still
-                            experimental.
-
-* `unboxed_closures` - A work in progress feature with many known bugs.
+* `unboxed_closures` - Rust's new closure design, which is currently a work in
+                       progress feature with many known bugs.
 
 * `unsafe_destructor` - Allows use of the `#[unsafe_destructor]` attribute,
                         which is considered wildly unsafe and will be

branches/snap-stage3/src/driver/driver.rs

@@ -12,6 +12,6 @@
 extern crate "rustdoc" as this;
 
 #[cfg(rustc)]
-extern crate "rustc" as this;
+extern crate "rustc_trans" as this;
 
 fn main() { this::main() }

branches/snap-stage3/src/libcore/iter.rs

@@ -65,9 +65,10 @@ use cmp;
 use cmp::Ord;
 use mem;
 use num::{ToPrimitive, Int};
-use ops::Add;
+use ops::{Add, Deref};
 use option::{Option, Some, None};
 use uint;
+
 #[deprecated = "renamed to Extend"] pub use self::Extend as Extendable;
 
 /// Conversion from an `Iterator`
@@ -1021,6 +1022,44 @@ impl<T: Clone> MinMaxResult<T> {
     }
 }
 
+/// A trait for iterators that contain cloneable elements
+pub trait CloneIteratorExt<A> {
+    /// Creates an iterator that clones the elements it yields. Useful for converting an
+    /// Iterator<&T> to an Iterator<T>.
+    fn cloned(self) -> Cloned<Self>;
+}
+
+
+impl<A: Clone, D: Deref<A>, I: Iterator<D>> CloneIteratorExt<A> for I {
+    fn cloned(self) -> Cloned<I> {
+        Cloned { it: self }
+    }
+}
+
+/// An iterator that clones the elements of an underlying iterator
+pub struct Cloned<I> {
+    it: I,
+}
+
+impl<A: Clone, D: Deref<A>, I: Iterator<D>> Iterator<A> for Cloned<I> {
+    fn next(&mut self) -> Option<A> {
+        self.it.next().cloned()
+    }
+
+    fn size_hint(&self) -> (uint, Option<uint>) {
+        self.it.size_hint()
+    }
+}
+
+impl<A: Clone, D: Deref<A>, I: DoubleEndedIterator<D>>
+        DoubleEndedIterator<A> for Cloned<I> {
+    fn next_back(&mut self) -> Option<A> {
+        self.it.next_back().cloned()
+    }
+}
+
+impl<A: Clone, D: Deref<A>, I: ExactSize<D>> ExactSize<A> for Cloned<I> {}
+
 /// A trait for iterators that are cloneable.
 pub trait CloneableIterator {
     /// Repeats an iterator endlessly

branches/snap-stage3/src/libcore/num/mod.rs

@@ -39,28 +39,10 @@ pub fn div_rem<T: Div<T, T> + Rem<T, T>>(x: T, y: T) -> (T, T) {
 }
 
 /// Raises a `base` to the power of `exp`, using exponentiation by squaring.
-///
-/// # Example
-///
-/// ```rust
-/// use std::num;
-///
-/// assert_eq!(num::pow(2i, 4), 16);
-/// ```
 #[inline]
-pub fn pow<T: Int>(mut base: T, mut exp: uint) -> T {
-    if exp == 1 { base }
-    else {
-        let mut acc: T = Int::one();
-        while exp > 0 {
-            if (exp & 1) == 1 {
-                acc = acc * base;
-            }
-            base = base * base;
-            exp = exp >> 1;
-        }
-        acc
-    }
+#[deprecated = "Use Int::pow() instead, as in 2i.pow(4)"]
+pub fn pow<T: Int>(base: T, exp: uint) -> T {
+    base.pow(exp)
 }
 
 /// A built-in signed or unsigned integer.
@@ -361,6 +343,29 @@ pub trait Int
             None                         => Int::max_value(),
         }
     }
+
+    /// Raises self to the power of `exp`, using exponentiation by squaring.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use std::num::Int;
+    ///
+    /// assert_eq!(2i.pow(4), 16);
+    /// ```
+    #[inline]
+    fn pow(self, mut exp: uint) -> Self {
+        let mut base = self;
+        let mut acc: Self = Int::one();
+        while exp > 0 {
+            if (exp & 1) == 1 {
+                acc = acc * base;
+            }
+            base = base * base;
+            exp /= 2;
+        }
+        acc
+    }
 }
 
 macro_rules! checked_op {

branches/snap-stage3/src/libcore/option.rs

@@ -153,6 +153,7 @@ use result::{Result, Ok, Err};
 use slice;
 use slice::AsSlice;
 use clone::Clone;
+use ops::Deref;
 
 // Note that this is not a lang item per se, but it has a hidden dependency on
 // `Iterator`, which is one. The compiler assumes that the `next` method of
@@ -694,11 +695,12 @@ impl<T> Option<T> {
     }
 }
 
-impl<'a, T: Clone> Option<&'a T> {
-    /// Maps an Option<&T> to an Option<T> by cloning the contents of the Option<&T>.
+impl<'a, T: Clone, D: Deref<T>> Option<D> {
+    /// Maps an Option<D> to an Option<T> by dereffing and cloning the contents of the Option.
+    /// Useful for converting an Option<&T> to an Option<T>.
     #[unstable = "recently added as part of collections reform"]
     pub fn cloned(self) -> Option<T> {
-        self.map(|t| t.clone())
+        self.map(|t| t.deref().clone())
     }
 }
 

branches/snap-stage3/src/libcoretest/iter.rs

@@ -440,6 +440,23 @@ fn test_rev() {
             vec![16, 14, 12, 10, 8, 6]);
 }
 
+#[test]
+fn test_cloned() {
+    let xs = [2u8, 4, 6, 8];
+
+    let mut it = xs.iter().cloned();
+    assert_eq!(it.len(), 4);
+    assert_eq!(it.next(), Some(2));
+    assert_eq!(it.len(), 3);
+    assert_eq!(it.next(), Some(4));
+    assert_eq!(it.len(), 2);
+    assert_eq!(it.next_back(), Some(8));
+    assert_eq!(it.len(), 1);
+    assert_eq!(it.next_back(), Some(6));
+    assert_eq!(it.len(), 0);
+    assert_eq!(it.next_back(), None);
+}
+
 #[test]
 fn test_double_ended_map() {
     let xs = [1i, 2, 3, 4, 5, 6];

branches/snap-stage3/src/libcoretest/option.rs

@@ -241,14 +241,29 @@ fn test_collect() {
     assert!(v == None);
 }
 
+#[test]
 fn test_cloned() {
-    let s = 1u32;
-    let n: Option<&'static u32> = None;
-    let o = Some(&s);
-
-    assert_eq!(o.clone(), Some(&s));
-    assert_eq!(o.cloned(), Some(1u32));
-
-    assert_eq!(n.clone(), None);
-    assert_eq!(n.cloned(), None);
+    let val1 = 1u32;
+    let mut val2 = 2u32;
+    let val1_ref = &val1;
+    let opt_none: Option<&'static u32> = None;
+    let opt_ref = Some(&val1);
+    let opt_ref_ref = Some(&val1_ref);
+    let opt_mut_ref = Some(&mut val2);
+
+    // None works
+    assert_eq!(opt_none.clone(), None);
+    assert_eq!(opt_none.cloned(), None);
+
+    // Mutable refs work
+    assert_eq!(opt_mut_ref.cloned(), Some(2u32));
+
+    // Immutable ref works
+    assert_eq!(opt_ref.clone(), Some(&val1));
+    assert_eq!(opt_ref.cloned(), Some(1u32));
+
+    // Double Immutable ref works
+    assert_eq!(opt_ref_ref.clone(), Some(&val1_ref));
+    assert_eq!(opt_ref_ref.clone().cloned(), Some(&val1));
+    assert_eq!(opt_ref_ref.cloned().cloned(), Some(1u32));
 }

branches/snap-stage3/src/libgraphviz/lib.rs

@@ -90,7 +90,7 @@ impl<'a> dot::GraphWalk<'a, Nd, Ed> for Edges {
     fn target(&self, e: &Ed) -> Nd { let &(_,t) = e; t }
 }
 
-# pub fn main() { use std::io::MemWriter; render_to(&mut MemWriter::new()) }
+# pub fn main() { render_to(&mut Vec::new()) }
 ```
 
 ```no_run
@@ -182,7 +182,7 @@ impl<'a> dot::GraphWalk<'a, Nd, Ed<'a>> for Graph {
     fn target(&self, e: &Ed) -> Nd { let & &(_,t) = e; t }
 }
 
-# pub fn main() { use std::io::MemWriter; render_to(&mut MemWriter::new()) }
+# pub fn main() { render_to(&mut Vec::new()) }
 ```
 
 ```no_run
@@ -246,7 +246,7 @@ impl<'a> dot::GraphWalk<'a, Nd<'a>, Ed<'a>> for Graph {
     fn target(&self, e: &Ed<'a>) -> Nd<'a> { let &(_,t) = e; t }
 }
 
-# pub fn main() { use std::io::MemWriter; render_to(&mut MemWriter::new()) }
+# pub fn main() { render_to(&mut Vec::new()) }
 ```
 
 ```no_run
@@ -274,7 +274,7 @@ pub fn main() {
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/nightly/")]
-#![feature(globs)]
+#![feature(globs, slicing_syntax)]
 
 pub use self::LabelText::*;
 
@@ -553,7 +553,7 @@ mod tests {
     use self::NodeLabels::*;
     use super::{Id, LabelText, LabelStr, EscStr, Labeller};
     use super::{Nodes, Edges, GraphWalk, render};
-    use std::io::{MemWriter, BufReader, IoResult};
+    use std::io::{BufReader, IoResult};
     use std::str;
 
     /// each node is an index in a vector in the graph.
@@ -702,9 +702,9 @@ mod tests {
     }
 
     fn test_input(g: LabelledGraph) -> IoResult<String> {
-        let mut writer = MemWriter::new();
+        let mut writer = Vec::new();
         render(&g, &mut writer).unwrap();
-        let mut r = BufReader::new(writer.get_ref());
+        let mut r = BufReader::new(writer[]);
         r.read_to_string()
     }
 
@@ -809,15 +809,15 @@ r#"digraph hasse_diagram {
             "branch2",
             "afterward"));
 
-        let mut writer = MemWriter::new();
+        let mut writer = Vec::new();
 
         let g = LabelledGraphWithEscStrs::new(
             "syntax_tree", labels,
             vec!(edge(0, 1, "then"), edge(0, 2, "else"),
                  edge(1, 3, ";"),    edge(2, 3, ";"   )));
 
         render(&g, &mut writer).unwrap();
-        let mut r = BufReader::new(writer.get_ref());
+        let mut r = BufReader::new(writer[]);
         let r = r.read_to_string();
 
         assert_eq!(r.unwrap().as_slice(),