---

yaml
---
r: 159518
b: refs/heads/master
c: 7ef2007
h: refs/heads/master
v: v3

Author: murarth

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 1628b98183bfec13e9407a905324dda047c3a550
+refs/heads/master: 7ef200774fbb8e5f4961f63a83cf5bbe27cd5f8f
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 9c96a79a74f10bed18b031ce0ac4126c56d6cfb3
 refs/heads/try: f58aad6dce273570fb130b4df008ef9acd5a5be2

trunk/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 rustc_trans rustdoc regex_macros fmt_macros \
+HOST_CRATES := syntax rustc rustdoc regex_macros fmt_macros \
 	       rustc_llvm rustc_back
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
@@ -69,12 +69,11 @@ 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 rustc_trans native:hoedown serialize getopts \
+DEPS_rustdoc := rustc native:hoedown serialize getopts \
                 test time
 DEPS_flate := std native:miniz
 DEPS_arena := std
@@ -97,7 +96,7 @@ DEPS_fmt_macros = std
 
 TOOL_DEPS_compiletest := test getopts native
 TOOL_DEPS_rustdoc := rustdoc native
-TOOL_DEPS_rustc := rustc_trans native
+TOOL_DEPS_rustc := rustc 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
@@ -113,8 +112,8 @@ ONLY_RLIB_unicode := 1
 # You should not need to edit below this line
 ################################################################################
 
-DOC_CRATES := $(filter-out rustc, $(filter-out rustc_trans, $(filter-out syntax, $(CRATES))))
-COMPILER_DOC_CRATES := rustc rustc_trans syntax
+DOC_CRATES := $(filter-out rustc, $(filter-out syntax, $(CRATES)))
+COMPILER_DOC_CRATES := rustc syntax
 
 # This macro creates some simple definitions for each crate being built, just
 # some munging of all of the parameters above.

trunk/src/doc/reference.md

@@ -2513,6 +2513,11 @@ 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
@@ -2555,8 +2560,11 @@ 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_closures` - Rust's new closure design, which is currently a work in
-                       progress feature with many known bugs.
+* `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.
 
 * `unsafe_destructor` - Allows use of the `#[unsafe_destructor]` attribute,
                         which is considered wildly unsafe and will be

trunk/src/driver/driver.rs

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

trunk/src/libcore/iter.rs

@@ -65,10 +65,9 @@ use cmp;
 use cmp::Ord;
 use mem;
 use num::{ToPrimitive, Int};
-use ops::{Add, Deref};
+use ops::Add;
 use option::{Option, Some, None};
 use uint;
-
 #[deprecated = "renamed to Extend"] pub use self::Extend as Extendable;
 
 /// Conversion from an `Iterator`
@@ -1022,44 +1021,6 @@ 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

trunk/src/libcore/num/mod.rs

@@ -39,10 +39,28 @@ 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]
-#[deprecated = "Use Int::pow() instead, as in 2i.pow(4)"]
-pub fn pow<T: Int>(base: T, exp: uint) -> T {
-    base.pow(exp)
+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
+    }
 }
 
 /// A built-in signed or unsigned integer.
@@ -343,29 +361,6 @@ 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 {

trunk/src/libcore/option.rs

@@ -153,7 +153,6 @@ 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
@@ -695,12 +694,11 @@ impl<T> 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>.
+impl<'a, T: Clone> Option<&'a T> {
+    /// Maps an Option<&T> to an Option<T> by cloning the contents of the Option<&T>.
     #[unstable = "recently added as part of collections reform"]
     pub fn cloned(self) -> Option<T> {
-        self.map(|t| t.deref().clone())
+        self.map(|t| t.clone())
     }
 }
 

trunk/src/libcoretest/iter.rs

@@ -440,23 +440,6 @@ 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];

trunk/src/libcoretest/option.rs

@@ -241,29 +241,14 @@ fn test_collect() {
     assert!(v == None);
 }
 
-#[test]
 fn test_cloned() {
-    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));
+    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);
 }

trunk/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() { render_to(&mut Vec::new()) }
+# pub fn main() { use std::io::MemWriter; render_to(&mut MemWriter::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() { render_to(&mut Vec::new()) }
+# pub fn main() { use std::io::MemWriter; render_to(&mut MemWriter::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() { render_to(&mut Vec::new()) }
+# pub fn main() { use std::io::MemWriter; render_to(&mut MemWriter::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, slicing_syntax)]
+#![feature(globs)]
 
 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::{BufReader, IoResult};
+    use std::io::{MemWriter, 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 = Vec::new();
+        let mut writer = MemWriter::new();
         render(&g, &mut writer).unwrap();
-        let mut r = BufReader::new(writer[]);
+        let mut r = BufReader::new(writer.get_ref());
         r.read_to_string()
     }
 
@@ -809,15 +809,15 @@ r#"digraph hasse_diagram {
             "branch2",
             "afterward"));
 
-        let mut writer = Vec::new();
+        let mut writer = MemWriter::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[]);
+        let mut r = BufReader::new(writer.get_ref());
         let r = r.read_to_string();
 
         assert_eq!(r.unwrap().as_slice(),