---

yaml
---
r: 83160
b: refs/heads/auto
c: 88ab38c
h: refs/heads/master
v: v3

Author: csainty

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 5d8e494a8c7d668eaac80fea59091a6e8fd70368
+refs/heads/auto: 88ab38cf060b794f3c4c3572cee7ca25354946d6
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/doc/rust.md

@@ -2067,6 +2067,10 @@ The currently implemented features of the compiler are:
                      For now this style of variant is hidden behind a feature
                      flag.
 
+* `once_fns` - Onceness guarantees a closure is only executed once. Defining a
+               closure as `once` is unlikely to be supported going forward. So
+               they are hidden behind this feature until they are to be removed. 
+
 If a feature is promoted to a language feature, then all existing programs will
 start to receive compilation warnings about #[feature] directives which enabled
 the new feature (because the directive is no longer necessary). However, if

branches/auto/src/librustc/driver/session.rs

@@ -1,4 +1,4 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -74,12 +74,11 @@ pub static statik:                  uint = 1 << 21;
 pub static print_link_args:         uint = 1 << 22;
 pub static no_debug_borrows:        uint = 1 << 23;
 pub static lint_llvm:               uint = 1 << 24;
-pub static once_fns:                uint = 1 << 25;
-pub static print_llvm_passes:       uint = 1 << 26;
-pub static no_vectorize_loops:      uint = 1 << 27;
-pub static no_vectorize_slp:        uint = 1 << 28;
-pub static no_prepopulate_passes:   uint = 1 << 29;
-pub static use_softfp:              uint = 1 << 30;
+pub static print_llvm_passes:       uint = 1 << 25;
+pub static no_vectorize_loops:      uint = 1 << 26;
+pub static no_vectorize_slp:        uint = 1 << 27;
+pub static no_prepopulate_passes:   uint = 1 << 28;
+pub static use_softfp:              uint = 1 << 29;
 
 pub fn debugging_opts_map() -> ~[(&'static str, &'static str, uint)] {
     ~[("verbose", "in general, enable more debug printouts", verbose),
@@ -118,9 +117,6 @@ pub fn debugging_opts_map() -> ~[(&'static str, &'static str, uint)] {
      ("lint-llvm",
       "Run the LLVM lint pass on the pre-optimization IR",
       lint_llvm),
-     ("once-fns",
-      "Allow 'once fn' closures to deinitialize captured variables",
-      once_fns),
      ("print-llvm-passes",
       "Prints the llvm optimization passes being run",
       print_llvm_passes),
@@ -326,7 +322,6 @@ impl Session_ {
     pub fn debug_borrows(&self) -> bool {
         self.opts.optimize == No && !self.debugging_opt(no_debug_borrows)
     }
-    pub fn once_fns(&self) -> bool { self.debugging_opt(once_fns) }
     pub fn print_llvm_passes(&self) -> bool {
         self.debugging_opt(print_llvm_passes)
     }

branches/auto/src/librustc/front/feature_gate.rs

@@ -33,6 +33,7 @@ static KNOWN_FEATURES: &'static [(&'static str, Status)] = &[
     ("globs", Active),
     ("macro_rules", Active),
     ("struct_variant", Active),
+    ("once_fns", Active),
 
     // These are used to test this portion of the compiler, they don't actually
     // mean anything
@@ -126,6 +127,20 @@ impl Visitor<()> for Context {
 
         visit::walk_item(self, i, ());
     }
+
+    fn visit_ty(&mut self, t: &ast::Ty, _: ()) {
+        match t.node {
+            ast::ty_closure(closure) if closure.onceness == ast::Once => {
+                self.gate_feature("once_fns", t.span,
+                                  "once functions are \
+                                   experimental and likely to be removed");
+
+            },
+            _ => {}
+        }
+
+        visit::walk_ty(self, t, ());
+    }
 }
 
 pub fn check_crate(sess: Session, crate: &ast::Crate) {

branches/auto/src/librustc/middle/borrowck/gather_loans/gather_moves.rs

@@ -1,4 +1,4 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -102,25 +102,13 @@ fn check_is_legal_to_move_from(bccx: &BorrowckCtxt,
     match cmt.cat {
         mc::cat_deref(_, _, mc::region_ptr(*)) |
         mc::cat_deref(_, _, mc::gc_ptr(*)) |
-        mc::cat_deref(_, _, mc::unsafe_ptr(*)) => {
-            bccx.span_err(
-                cmt0.span,
-                format!("cannot move out of {}",
-                     bccx.cmt_to_str(cmt)));
-            false
-        }
-
-        // These are separate from the above cases for a better error message.
+        mc::cat_deref(_, _, mc::unsafe_ptr(*)) |
         mc::cat_stack_upvar(*) |
         mc::cat_copied_upvar(mc::CopiedUpvar { onceness: ast::Many, _ }) => {
-            let once_hint = if bccx.tcx.sess.once_fns() {
-                " (unless the destination closure type is `once fn')"
-            } else {
-                ""
-            };
             bccx.span_err(
                 cmt0.span,
-                format!("cannot move out of {}{}", bccx.cmt_to_str(cmt), once_hint));
+                format!("cannot move out of {}",
+                     bccx.cmt_to_str(cmt)));
             false
         }
 

branches/auto/src/librustc/middle/mem_categorization.rs

@@ -1,4 +1,4 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -508,12 +508,10 @@ impl mem_categorization_ctxt {
                       let var_is_refd = match (closure_ty.sigil, closure_ty.onceness) {
                           // Many-shot stack closures can never move out.
                           (ast::BorrowedSigil, ast::Many) => true,
-                          // 1-shot stack closures can move out with "-Z once-fns".
-                          (ast::BorrowedSigil, ast::Once)
-                              if self.tcx.sess.once_fns() => false,
-                          (ast::BorrowedSigil, ast::Once) => true,
+                          // 1-shot stack closures can move out.
+                          (ast::BorrowedSigil, ast::Once) => false,
                           // Heap closures always capture by copy/move, and can
-                          // move out iff they are once.
+                          // move out if they are once.
                           (ast::OwnedSigil, _) |
                           (ast::ManagedSigil, _) => false,
 

branches/auto/src/librustc/middle/typeck/check/mod.rs

@@ -3645,7 +3645,7 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
               let fty = ty::mk_closure(ccx.tcx, ty::ClosureTy {
                   purity: ast::impure_fn,
                   sigil: ast::BorrowedSigil,
-                  onceness: ast::Once,
+                  onceness: ast::Many,
                   region: ty::re_bound(ty::br_anon(0)),
                   bounds: ty::EmptyBuiltinBounds(),
                   sig: ty::FnSig {

branches/auto/src/libstd/num/num.rs

@@ -42,26 +42,21 @@ pub trait Orderable: Ord {
     fn clamp(&self, mn: &Self, mx: &Self) -> Self;
 }
 
-/// Return the smaller number.
 #[inline(always)] pub fn min<T: Orderable>(x: T, y: T) -> T { x.min(&y) }
-/// Return the larger number.
 #[inline(always)] pub fn max<T: Orderable>(x: T, y: T) -> T { x.max(&y) }
-/// Returns the number constrained within the range `mn <= self <= mx`.
 #[inline(always)] pub fn clamp<T: Orderable>(value: T, mn: T, mx: T) -> T { value.clamp(&mn, &mx) }
 
 pub trait Zero {
     fn zero() -> Self;      // FIXME (#5527): This should be an associated constant
     fn is_zero(&self) -> bool;
 }
 
-/// Returns `0` of appropriate type.
 #[inline(always)] pub fn zero<T: Zero>() -> T { Zero::zero() }
 
 pub trait One {
     fn one() -> Self;       // FIXME (#5527): This should be an associated constant
 }
 
-/// Returns `1` of appropriate type.
 #[inline(always)] pub fn one<T: One>() -> T { One::one() }
 
 pub trait Signed: Num
@@ -74,26 +69,8 @@ pub trait Signed: Num
     fn is_negative(&self) -> bool;
 }
 
-/// Computes the absolute value.
-///
-/// For float, f32, and f64, `NaN` will be returned if the number is `NaN`
 #[inline(always)] pub fn abs<T: Signed>(value: T) -> T { value.abs() }
-/// The positive difference of two numbers.
-///
-/// Returns `zero` if the number is less than or equal to `other`,
-/// otherwise the difference between `self` and `other` is returned.
 #[inline(always)] pub fn abs_sub<T: Signed>(x: T, y: T) -> T { x.abs_sub(&y) }
-/// Returns the sign of the number.
-///
-/// For float, f32, f64:
-/// - `1.0` if the number is positive, `+0.0` or `infinity`
-/// - `-1.0` if the number is negative, `-0.0` or `neg_infinity`
-/// - `NaN` if the number is `NaN`
-///
-/// For int:
-/// - `0` if the number is zero
-/// - `1` if the number is positive
-/// - `-1` if the number is negative
 #[inline(always)] pub fn signum<T: Signed>(value: T) -> T { value.signum() }
 
 pub trait Unsigned: Num {}
@@ -129,11 +106,7 @@ pub trait Integer: Num
     fn is_odd(&self) -> bool;
 }
 
-/// Calculates the Greatest Common Divisor (GCD) of the number and `other`.
-///
-/// The result is always positive.
 #[inline(always)] pub fn gcd<T: Integer>(x: T, y: T) -> T { x.gcd(&y) }
-/// Calculates the Lowest Common Multiple (LCM) of the number and `other`.
 #[inline(always)] pub fn lcm<T: Integer>(x: T, y: T) -> T { x.lcm(&y) }
 
 pub trait Round {
@@ -159,23 +132,10 @@ pub trait Algebraic {
     fn hypot(&self, other: &Self) -> Self;
 }
 
-/// Raise a number to a power.
-///
-/// # Example
-///
-/// ```rust
-/// let sixteen: float = num::pow(2.0, 4.0);
-/// assert_eq!(sixteen, 16.0);
-/// ```
 #[inline(always)] pub fn pow<T: Algebraic>(value: T, n: T) -> T { value.pow(&n) }
-/// Take the squre root of a number.
 #[inline(always)] pub fn sqrt<T: Algebraic>(value: T) -> T { value.sqrt() }
-/// Take the reciprocal (inverse) square root of a number, `1/sqrt(x)`.
 #[inline(always)] pub fn rsqrt<T: Algebraic>(value: T) -> T { value.rsqrt() }
-/// Take the cubic root of a number.
 #[inline(always)] pub fn cbrt<T: Algebraic>(value: T) -> T { value.cbrt() }
-/// Calculate the length of the hypotenuse of a right-angle triangle given legs of length `x` and
-/// `y`.
 #[inline(always)] pub fn hypot<T: Algebraic>(x: T, y: T) -> T { x.hypot(&y) }
 
 pub trait Trigonometric {
@@ -191,23 +151,15 @@ pub trait Trigonometric {
     fn sin_cos(&self) -> (Self, Self);
 }
 
-/// Sine function.
 #[inline(always)] pub fn sin<T: Trigonometric>(value: T) -> T { value.sin() }
-/// Cosine function.
 #[inline(always)] pub fn cos<T: Trigonometric>(value: T) -> T { value.cos() }
-/// Tangent function.
 #[inline(always)] pub fn tan<T: Trigonometric>(value: T) -> T { value.tan() }
 
-/// Compute the arcsine of the number.
 #[inline(always)] pub fn asin<T: Trigonometric>(value: T) -> T { value.asin() }
-/// Compute the arccosine of the number.
 #[inline(always)] pub fn acos<T: Trigonometric>(value: T) -> T { value.acos() }
-/// Compute the arctangent of the number.
 #[inline(always)] pub fn atan<T: Trigonometric>(value: T) -> T { value.atan() }
 
-/// Compute the arctangent with 2 arguments.
 #[inline(always)] pub fn atan2<T: Trigonometric>(x: T, y: T) -> T { x.atan2(&y) }
-/// Simultaneously computes the sine and cosine of the number.
 #[inline(always)] pub fn sin_cos<T: Trigonometric>(value: T) -> (T, T) { value.sin_cos() }
 
 pub trait Exponential {
@@ -220,18 +172,12 @@ pub trait Exponential {
     fn log10(&self) -> Self;
 }
 
-/// Returns `e^(value)`, (the exponential function).
 #[inline(always)] pub fn exp<T: Exponential>(value: T) -> T { value.exp() }
-/// Returns 2 raised to the power of the number, `2^(value)`.
 #[inline(always)] pub fn exp2<T: Exponential>(value: T) -> T { value.exp2() }
 
-/// Returns the natural logarithm of the number.
 #[inline(always)] pub fn ln<T: Exponential>(value: T) -> T { value.ln() }
-/// Returns the logarithm of the number with respect to an arbitrary base.
 #[inline(always)] pub fn log<T: Exponential>(value: T, base: T) -> T { value.log(&base) }
-/// Returns the base 2 logarithm of the number.
 #[inline(always)] pub fn log2<T: Exponential>(value: T) -> T { value.log2() }
-/// Returns the base 10 logarithm of the number.
 #[inline(always)] pub fn log10<T: Exponential>(value: T) -> T { value.log10() }
 
 pub trait Hyperbolic: Exponential {
@@ -244,18 +190,12 @@ pub trait Hyperbolic: Exponential {
     fn atanh(&self) -> Self;
 }
 
-/// Hyperbolic cosine function.
 #[inline(always)] pub fn sinh<T: Hyperbolic>(value: T) -> T { value.sinh() }
-/// Hyperbolic sine function.
 #[inline(always)] pub fn cosh<T: Hyperbolic>(value: T) -> T { value.cosh() }
-/// Hyperbolic tangent function.
 #[inline(always)] pub fn tanh<T: Hyperbolic>(value: T) -> T { value.tanh() }
 
-/// Inverse hyperbolic sine function.
 #[inline(always)] pub fn asinh<T: Hyperbolic>(value: T) -> T { value.asinh() }
-/// Inverse hyperbolic cosine function.
 #[inline(always)] pub fn acosh<T: Hyperbolic>(value: T) -> T { value.acosh() }
-/// Inverse hyperbolic tangent function.
 #[inline(always)] pub fn atanh<T: Hyperbolic>(value: T) -> T { value.atanh() }
 
 /// Defines constants and methods common to real numbers
@@ -405,16 +345,8 @@ pub trait Float: Real
     fn next_after(&self, other: Self) -> Self;
 }
 
-/// Returns the exponential of the number, minus `1`, `exp(n) - 1`, in a way
-/// that is accurate even if the number is close to zero.
 #[inline(always)] pub fn exp_m1<T: Float>(value: T) -> T { value.exp_m1() }
-/// Returns the natural logarithm of the number plus `1`, `ln(n + 1)`, more
-/// accurately than if the operations were performed separately.
 #[inline(always)] pub fn ln_1p<T: Float>(value: T) -> T { value.ln_1p() }
-/// Fused multiply-add. Computes `(a * b) + c` with only one rounding error.
-///
-/// This produces a more accurate result with better performance (on some
-/// architectures) than a separate multiplication operation followed by an add.
 #[inline(always)] pub fn mul_add<T: Float>(a: T, b: T, c: T) -> T { a.mul_add(b, c) }
 
 /// A generic trait for converting a value to a number.
@@ -856,7 +788,7 @@ impl_from_primitive!(u64, n.to_u64())
 impl_from_primitive!(f32, n.to_f32())
 impl_from_primitive!(f64, n.to_f64())
 
-/// Cast from one machine scalar to another.
+/// Cast from one machine scalar to another
 ///
 /// # Example
 ///
@@ -909,7 +841,7 @@ pub trait FromStrRadix {
     fn from_str_radix(str: &str, radix: uint) -> Option<Self>;
 }
 
-/// A utility function that just calls FromStrRadix::from_str_radix.
+/// A utility function that just calls FromStrRadix::from_str_radix
 pub fn from_str_radix<T: FromStrRadix>(str: &str, radix: uint) -> Option<T> {
     FromStrRadix::from_str_radix(str, radix)
 }

branches/auto/src/libstd/unstable/intrinsics.rs

@@ -331,7 +331,8 @@ extern "rust-intrinsic" {
 
     pub fn visit_tydesc(td: *TyDesc, tv: &mut TyVisitor);
 
-    pub fn frame_address(f: &once fn(*u8));
+    #[cfg(not(stage0))]
+    pub fn frame_address(f: &fn(*u8));
 
     /// Get the address of the `__morestack` stack growth function.
     pub fn morestack_addr() -> *();

branches/auto/src/test/compile-fail/once-cant-call-twice-on-heap.rs

@@ -11,6 +11,7 @@
 // Testing guarantees provided by once functions.
 // This program would segfault if it were legal.
 
+#[feature(once_fns)];
 extern mod extra;
 use extra::arc;
 use std::util;

branches/auto/src/test/compile-fail/once-cant-call-twice-on-stack.rs

@@ -11,7 +11,7 @@
 // Testing guarantees provided by once functions.
 // This program would segfault if it were legal.
 
-// compile-flags:-Z once-fns
+#[feature(once_fns)];
 extern mod extra;
 use extra::arc;
 use std::util;

branches/auto/src/test/compile-fail/once-fn-subtyping.rs

@@ -1,4 +1,4 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#[feature(once_fns)];
 fn main() {
     let f: &once fn() = ||();
     let g: &fn() = f;  //~ ERROR mismatched types

branches/auto/src/test/run-pass/intrinsic-frame-address.rs

@@ -1,4 +1,4 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -12,7 +12,7 @@
 
 mod rusti {
     extern "rust-intrinsic" {
-        pub fn frame_address(f: &once fn(*u8));
+        pub fn frame_address(f: &fn(*u8));
     }
 }