---

yaml
---
r: 159750
b: refs/heads/auto
c: 058abcc
h: refs/heads/master
v: v3

Author: nikomatsakis

[refs]

@@ -10,7 +10,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 09e2ad13d0aa01143bcb20dece3ff6c5a7e34ea3
+refs/heads/auto: 058abcc2094f7657063748f038470076b1e73a63
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/doc/reference.md

@@ -2560,10 +2560,6 @@ 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.
 
 * `unsafe_destructor` - Allows use of the `#[unsafe_destructor]` attribute,

branches/auto/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

branches/auto/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())
     }
 }
 

branches/auto/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];

branches/auto/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);
 }

branches/auto/src/libsyntax/feature_gate.rs

@@ -59,7 +59,6 @@ static KNOWN_FEATURES: &'static [(&'static str, Status)] = &[
     ("linkage", Active),
     ("struct_inherit", Removed),
     ("overloaded_calls", Active),
-    ("unboxed_closure_sugar", Active),
 
     ("quad_precision_float", Removed),
 
@@ -381,7 +380,7 @@ impl<'a, 'v> Visitor<'v> for Context<'a> {
                 fn_decl: &'v ast::FnDecl,
                 block: &'v ast::Block,
                 span: Span,
-                _: NodeId) {
+                _node_id: NodeId) {
         match fn_kind {
             visit::FkItemFn(_, _, _, abi) if abi == RustIntrinsic => {
                 self.gate_feature("intrinsics",
@@ -392,6 +391,19 @@ impl<'a, 'v> Visitor<'v> for Context<'a> {
         }
         visit::walk_fn(self, fn_kind, fn_decl, block, span);
     }
+
+    fn visit_path_parameters(&mut self, path_span: Span, parameters: &'v ast::PathParameters) {
+        match *parameters {
+            ast::ParenthesizedParameters(..) => {
+                self.gate_feature("unboxed_closures",
+                                  path_span,
+                                  "parenthetical parameter notation is subject to change");
+            }
+            ast::AngleBracketedParameters(..) => { }
+        }
+
+        visit::walk_path_parameters(self, path_span, parameters)
+    }
 }
 
 pub fn check_crate(span_handler: &SpanHandler, krate: &ast::Crate) -> (Features, Vec<Span>) {

branches/auto/src/test/compile-fail/borrowck-unboxed-closures.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(overloaded_calls)]
+#![feature(overloaded_calls, unboxed_closures)]
 
 fn a<F:Fn(int, int) -> int>(mut f: F) {
     let g = &mut f;

branches/auto/src/test/compile-fail/issue-16939.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(overloaded_calls)]
+#![feature(overloaded_calls, unboxed_closures)]
 
 // Make sure we don't ICE when making an overloaded call with the
 // wrong arity.

branches/auto/src/test/compile-fail/regionck-unboxed-closure-lifetimes.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(unboxed_closure_sugar, unboxed_closures, overloaded_calls)]
+#![feature(unboxed_closures, overloaded_calls)]
 
 use std::ops::FnMut;
 

branches/auto/src/test/compile-fail/unboxed-closure-sugar-default.rs

@@ -11,7 +11,7 @@
 // Test interaction between unboxed closure sugar and default type
 // parameters (should be exactly as if angle brackets were used).
 
-#![feature(default_type_params)]
+#![feature(default_type_params, unboxed_closures)]
 #![allow(dead_code)]
 
 struct Foo<T,U,V=T> {

branches/auto/src/test/compile-fail/unboxed-closure-sugar-equiv.rs

@@ -13,6 +13,7 @@
 // angle brackets. This test covers only simple types and in
 // particular doesn't test bound regions.
 
+#![feature(unboxed_closures)]
 #![allow(dead_code)]
 
 struct Foo<T,U> {

branches/auto/src/test/compile-fail/unboxed-closure-sugar-nonexistent-trait.rs

@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(unboxed_closures)]
+
 fn f<F:Nonexist(int) -> int>(x: F) {} //~ ERROR nonexistent trait `Nonexist`
 
 type Typedef = int;

branches/auto/src/test/compile-fail/unboxed-closure-sugar-region.rs

@@ -12,7 +12,7 @@
 // parameters (should be exactly as if angle brackets were used
 // and regions omitted).
 
-#![feature(default_type_params)]
+#![feature(default_type_params, unboxed_closures)]
 #![allow(dead_code)]
 
 use std::kinds::marker;

branches/auto/src/test/compile-fail/unboxed-closure-sugar-wrong-number-number-type-parameters-1.rs

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 struct One<A>;
+#![feature(unboxed_closures)]
 
 fn foo(_: One()) //~ ERROR wrong number of type arguments
 {}

branches/auto/src/test/compile-fail/unboxed-closure-sugar-wrong-number-number-type-parameters-3.rs

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 struct Three<A,B,C>;
+#![feature(unboxed_closures)]
 
 fn foo(_: Three()) //~ ERROR wrong number of type arguments
 {}

branches/auto/src/test/compile-fail/unboxed-closure-sugar-wrong-number-number-type-parameters.rs

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 struct Zero;
+#![feature(unboxed_closures)]
 
 fn foo(_: Zero()) //~ ERROR wrong number of type arguments
 {}

branches/auto/src/test/compile-fail/unboxed-closure-sugar-wrong-trait.rs

@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(unboxed_closures)]
+
 trait Trait {}
 
 fn f<F:Trait(int) -> int>(x: F) {}

branches/auto/src/test/compile-fail/unboxed-closures-fnmut-as-fn.rs

@@ -11,7 +11,7 @@
 // Checks that the Fn trait hierarchy rules do not permit
 // Fn to be used where FnMut is implemented.
 
-#![feature(unboxed_closure_sugar)]
+#![feature(unboxed_closures)]
 #![feature(overloaded_calls)]
 
 use std::ops::{Fn,FnMut,FnOnce};

branches/auto/src/test/run-pass/closure-syntax.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 #![allow(dead_code)]
-#![feature(unboxed_closures, unboxed_closure_sugar)]
+#![feature(unboxed_closures)]
 
 // compile-flags:-g
 

branches/auto/src/test/run-pass/hrtb-parse.rs

@@ -11,6 +11,7 @@
 // Test that we can parse all the various places that a `for` keyword
 // can appear representing universal quantification.
 
+#![feature(unboxed_closures)]
 #![allow(unused_variables)]
 #![allow(dead_code)]
 

branches/auto/src/test/run-pass/issue-18661.rs

@@ -11,7 +11,7 @@
 // Test that param substitutions from the correct environment are
 // used when translating unboxed closure calls.
 
-#![feature(unboxed_closures)]
+#![feature(unboxed_closures, unboxed_closures)]
 
 pub fn inside<F: Fn()>(c: F) {
     c.call(());

branches/auto/src/test/run-pass/unboxed-closures-all-traits.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(lang_items, overloaded_calls, unboxed_closures)]
+#![feature(lang_items, overloaded_calls, unboxed_closures, unboxed_closures)]
 
 fn a<F:Fn(int, int) -> int>(f: F) -> int {
     f(1, 2)

branches/auto/src/test/run-pass/unboxed-closures-extern-fn.rs

@@ -10,7 +10,7 @@
 
 // Checks that extern fn points implement the full range of Fn traits.
 
-#![feature(unboxed_closure_sugar)]
+#![feature(unboxed_closures)]
 #![feature(overloaded_calls)]
 
 use std::ops::{Fn,FnMut,FnOnce};

branches/auto/src/test/run-pass/unboxed-closures-fn-as-fnmut-and-fnonce.rs

@@ -11,7 +11,7 @@
 // Checks that the Fn trait hierarchy rules permit
 // any Fn trait to be used where Fn is implemented.
 
-#![feature(unboxed_closure_sugar)]
+#![feature(unboxed_closures)]
 #![feature(overloaded_calls)]
 
 use std::ops::{Fn,FnMut,FnOnce};

branches/auto/src/test/run-pass/unboxed-closures-fnmut-as-fnonce.rs

@@ -11,7 +11,7 @@
 // Checks that the Fn trait hierarchy rules permit
 // FnMut or FnOnce to be used where FnMut is implemented.
 
-#![feature(unboxed_closure_sugar)]
+#![feature(unboxed_closures)]
 #![feature(overloaded_calls)]
 
 use std::ops::{FnMut,FnOnce};

branches/auto/src/test/run-pass/unboxed-closures-manual-impl.rs

@@ -9,7 +9,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(unboxed_closure_sugar)]
+#![feature(unboxed_closures)]
 
 use std::ops::FnMut;
 

branches/auto/src/test/run-pass/unboxed-closures-prelude.rs

@@ -10,7 +10,7 @@
 
 // Tests that the reexports of `FnOnce` et al from the prelude work.
 
-#![feature(unboxed_closures, unboxed_closure_sugar)]
+#![feature(unboxed_closures)]
 
 fn main() {
     let task: Box<FnOnce(int) -> int> = box |: x| x;

branches/auto/src/test/run-pass/unboxed-closures-sugar-object.rs

@@ -11,6 +11,7 @@
 // Test unboxed closure sugar used in object types.
 
 #![allow(dead_code)]
+#![feature(unboxed_closures)]
 
 struct Foo<T,U> {
     t: T, u: U