---

yaml
---
r: 212079
b: refs/heads/tmp
c: 81a413b
h: refs/heads/master
i:
  212077: f83cf86
  212075: 65a7eeb
  212071: d88ed04
  212063: 3144c7b
v: v3

Author: nhowell

[refs]

@@ -32,7 +32,7 @@ refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
 refs/heads/beta: 62e70d35be3fe532c26a400b499c58a18f18dd3a
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: 253fb5bd8b7b5b433f67c88c4d9a89130743b059
+refs/heads/tmp: 81a413bb011ef7051073bc0c1cea735f45e64ce8
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: b77d60adb019bb5de05e884a99f3290ec4694137
 refs/heads/gate: 97c84447b65164731087ea82685580cc81424412

branches/tmp/src/doc/style/features/functions-and-methods/README.md

@@ -20,7 +20,6 @@ for any operation that is clearly associated with a particular
 type.
 
 Methods have numerous advantages over functions:
-
 * They do not need to be imported or qualified to be used: all you
   need is a value of the appropriate type.
 * Their invocation performs autoborrowing (including mutable borrows).

branches/tmp/src/doc/style/features/functions-and-methods/input.md

@@ -159,7 +159,7 @@ fn foo(a: u8) { ... }
 Note that
 [`ascii::Ascii`](http://static.rust-lang.org/doc/master/std/ascii/struct.Ascii.html)
 is a _wrapper_ around `u8` that guarantees the highest bit is zero; see
-[newtype patterns](../types/newtype.md) for more details on creating typesafe wrappers.
+[newtype patterns]() for more details on creating typesafe wrappers.
 
 Static enforcement usually comes at little run-time cost: it pushes the
 costs to the boundaries (e.g. when a `u8` is first converted into an

branches/tmp/src/doc/style/features/let.md

@@ -34,7 +34,7 @@ Prefer
 
 ```rust
 let foo = match bar {
-    Baz => 0,
+    Baz  => 0,
     Quux => 1
 };
 ```
@@ -44,7 +44,7 @@ over
 ```rust
 let foo;
 match bar {
-    Baz => {
+    Baz  => {
         foo = 0;
     }
     Quux => {
@@ -61,8 +61,8 @@ conditional expression.
 Prefer
 
 ```rust
-let v = s.iter().map(|x| x * 2)
-                .collect::<Vec<_>>();
+s.iter().map(|x| x * 2)
+        .collect::<Vec<_>>()
 ```
 
 over

branches/tmp/src/doc/style/ownership/builders.md

@@ -16,7 +16,7 @@ If `T` is such a data structure, consider introducing a `T` _builder_:
    value. When possible, choose a better name: e.g. `Command` is the builder for
    `Process`.
 2. The builder constructor should take as parameters only the data _required_ to
-   make a `T`.
+   to make a `T`.
 3. The builder should offer a suite of convenient methods for configuration,
    including setting up compound inputs (like slices) incrementally.
    These methods should return `self` to allow chaining.

branches/tmp/src/doc/trpl/README.md

@@ -15,7 +15,7 @@ language would.
 
 [rust]: http://rust-lang.org
 
-“The Rust Programming Language” is split into seven sections. This introduction
+“The Rust Programming Language” is split into eight sections. This introduction
 is the first. After this:
 
 * [Getting started][gs] - Set up your computer for Rust development.

branches/tmp/src/doc/trpl/glossary.md

@@ -19,7 +19,7 @@ In the example above `x` and `y` have arity 2. `z` has arity 3.
 
 When a compiler is compiling your program, it does a number of different
 things. One of the things that it does is turn the text of your program into an
-‘abstract syntax tree’, or ‘AST’. This tree is a representation of the
+‘abstract syntax tree’, or‘AST’. This tree is a representation of the
 structure of your program. For example, `2 + 3` can be turned into a tree:
 
 ```text

branches/tmp/src/doc/trpl/lifetimes.md

@@ -134,29 +134,8 @@ x: &'a i32,
 # }
 ```
 
-uses it. So why do we need a lifetime here? We need to ensure that any reference
-to a `Foo` cannot outlive the reference to an `i32` it contains.
-
-If you have multiple references, you can use the same lifetime multiple times:
-
-```rust
-fn x_or_y<'a>(x: &'a str, y: &'a str) -> &'a str {
-#    x
-# }
-```
-
-This says that `x` and `y` both are alive for the same scope, and that the
-return value is also alive for that scope. If you wanted `x` and `y` to have
-different lifetimes, you can use multiple lifetime parameters:
-
-```rust
-fn x_or_y<'a, 'b>(x: &'a str, y: &'b str) -> &'a str {
-#    x
-# }
-```
-
-In this example, `x` and `y` have different valid scopes, but the return value
-has the same lifetime as `x`.
+uses it. So why do we need a lifetime here? We need to ensure that any
+reference to the contained `i32` does not outlive the containing `Foo`.
 
 ## Thinking in scopes
 

branches/tmp/src/doc/trpl/method-syntax.md

@@ -4,7 +4,7 @@ Functions are great, but if you want to call a bunch of them on some data, it
 can be awkward. Consider this code:
 
 ```rust,ignore
-baz(bar(foo));
+baz(bar(foo)));
 ```
 
 We would read this left-to right, and so we see ‘baz bar foo’. But this isn’t the

branches/tmp/src/doc/trpl/traits.md

@@ -285,7 +285,7 @@ fn bar<T, K>(x: T, y: K) where T: Clone, K: Clone + Debug {
 
 fn main() {
     foo("Hello", "world");
-    bar("Hello", "world");
+    bar("Hello", "workd");
 }
 ```
 

branches/tmp/src/libcollectionstest/lib.rs

@@ -14,7 +14,6 @@
 #![feature(collections)]
 #![feature(collections_drain)]
 #![feature(core)]
-#![feature(const_fn)]
 #![feature(hash)]
 #![feature(rand)]
 #![feature(rustc_private)]

branches/tmp/src/libcore/mem.rs

@@ -52,61 +52,20 @@ pub use intrinsics::transmute;
 /// * `mpsc::{Sender, Receiver}` cycles (they use `Arc` internally)
 /// * Panicking destructors are likely to leak local resources
 ///
-/// # When To Use
-///
-/// There's only a few reasons to use this function. They mainly come
-/// up in unsafe code or FFI code.
-///
-/// * You have an uninitialized value, perhaps for performance reasons, and
-///   need to prevent the destructor from running on it.
-/// * You have two copies of a value (like `std::mem::swap`), but need the
-///   destructor to only run once to prevent a double free.
-/// * Transferring resources across FFI boundries.
-///
 /// # Example
 ///
-/// Leak some heap memory by never deallocating it.
-///
-/// ```rust
+/// ```rust,no_run
 /// use std::mem;
+/// use std::fs::File;
 ///
+/// // Leak some heap memory by never deallocating it
 /// let heap_memory = Box::new(3);
 /// mem::forget(heap_memory);
-/// ```
-///
-/// Leak an I/O object, never closing the file.
-///
-/// ```rust,no_run
-/// use std::mem;
-/// use std::fs::File;
 ///
+/// // Leak an I/O object, never closing the file
 /// let file = File::open("foo.txt").unwrap();
 /// mem::forget(file);
 /// ```
-///
-/// The swap function uses forget to good effect.
-///
-/// ```rust
-/// use std::mem;
-/// use std::ptr;
-///
-/// fn swap<T>(x: &mut T, y: &mut T) {
-///     unsafe {
-///         // Give ourselves some scratch space to work with
-///         let mut t: T = mem::uninitialized();
-///
-///         // Perform the swap, `&mut` pointers never alias
-///         ptr::copy_nonoverlapping(&*x, &mut t, 1);
-///         ptr::copy_nonoverlapping(&*y, x, 1);
-///         ptr::copy_nonoverlapping(&t, y, 1);
-///
-///         // y and t now point to the same thing, but we need to completely
-///         // forget `t` because we do not want to run the destructor for `T`
-///         // on its value, which is still owned somewhere outside this function.
-///         mem::forget(t);
-///     }
-/// }
-/// ```
 #[stable(feature = "rust1", since = "1.0.0")]
 pub fn forget<T>(t: T) {
     unsafe { intrinsics::forget(t) }
@@ -308,9 +267,8 @@ pub fn swap<T>(x: &mut T, y: &mut T) {
         ptr::copy_nonoverlapping(&*y, x, 1);
         ptr::copy_nonoverlapping(&t, y, 1);
 
-        // y and t now point to the same thing, but we need to completely
-        // forget `t` because we do not want to run the destructor for `T`
-        // on its value, which is still owned somewhere outside this function.
+        // y and t now point to the same thing, but we need to completely forget `t`
+        // because it's no longer relevant.
         forget(t);
     }
 }

branches/tmp/src/libcoretest/lib.rs

@@ -14,7 +14,6 @@
 #![feature(box_syntax)]
 #![feature(unboxed_closures)]
 #![feature(core)]
-#![feature(const_fn)]
 #![feature(test)]
 #![feature(rand)]
 #![feature(unicode)]

branches/tmp/src/liblog/lib.rs

@@ -173,7 +173,6 @@
 #![feature(staged_api)]
 #![feature(box_syntax)]
 #![feature(core)]
-#![feature(const_fn)]
 #![feature(std_misc)]
 
 use std::boxed;

branches/tmp/src/librustc/diagnostics.rs

@@ -196,13 +196,9 @@ const Y: i32 = A;
 "##,
 
 E0015: r##"
-The only functions that can be called in static or constant expressions are
-`const` functions. Rust currently does not support more general compile-time
-function execution.
-
-See [RFC 911] for more details on the design of `const fn`s.
-
-[RFC 911]: https://github.com/rust-lang/rfcs/blob/master/text/0911-const-fn.md
+The only function calls allowed in static or constant expressions are enum
+variant constructors or struct constructors (for unit or tuple structs). This
+is because Rust currently does not support compile-time function execution.
 "##,
 
 E0018: r##"
@@ -846,53 +842,6 @@ struct Foo<T: 'static> {
     foo: &'static T
 }
 ```
-"##,
-
-E0378: r##"
-Method calls that aren't calls to inherent `const` methods are disallowed
-in statics, constants, and constant functions.
-
-For example:
-
-```
-const BAZ: i32 = Foo(25).bar(); // error, `bar` isn't `const`
-
-struct Foo(i32);
-
-impl Foo {
-    const fn foo(&self) -> i32 {
-        self.bar() // error, `bar` isn't `const`
-    }
-
-    fn bar(&self) -> i32 { self.0 }
-}
-```
-
-For more information about `const fn`'s, see [RFC 911].
-
-[RFC 911]: https://github.com/rust-lang/rfcs/blob/master/text/0911-const-fn.md
-"##,
-
-E0394: r##"
-From [RFC 246]:
-
- > It is illegal for a static to reference another static by value. It is
- > required that all references be borrowed.
-
-[RFC 246]: https://github.com/rust-lang/rfcs/pull/246
-"##,
-
-E0397: r##"
-It is not allowed for a mutable static to allocate or have destructors. For
-example:
-
-```
-// error: mutable statics are not allowed to have boxes
-static mut FOO: Option<Box<usize>> = None;
-
-// error: mutable statics are not allowed to have destructors
-static mut BAR: Option<Vec<i32>> = None;
-```
 "##
 
 }
@@ -942,6 +891,9 @@ register_diagnostics! {
     E0315, // cannot invoke closure outside of its lifetime
     E0316, // nested quantification of lifetimes
     E0370, // discriminant overflow
+    E0378, // method calls limited to constant inherent methods
+    E0394, // cannot refer to other statics by value, use the address-of
+           // operator or a constant instead
     E0395, // pointer comparison in const-expr
     E0396  // pointer dereference in const-expr
 }

branches/tmp/src/librustc/lib.rs

@@ -29,7 +29,6 @@
 #![feature(box_patterns)]
 #![feature(box_syntax)]
 #![feature(collections)]
-#![feature(const_fn)]
 #![feature(core)]
 #![feature(duration)]
 #![feature(duration_span)]

branches/tmp/src/librustc/middle/check_const.rs

@@ -199,32 +199,8 @@ impl<'a, 'tcx> CheckCrateVisitor<'a, 'tcx> {
     }
 
     /// Returns true if the call is to a const fn or method.
-    fn handle_const_fn_call(&mut self,
-                            expr: &ast::Expr,
-                            def_id: ast::DefId,
-                            ret_ty: Ty<'tcx>)
-                            -> bool {
+    fn handle_const_fn_call(&mut self, def_id: ast::DefId, ret_ty: Ty<'tcx>) -> bool {
         if let Some(fn_like) = const_eval::lookup_const_fn_by_id(self.tcx, def_id) {
-            if
-                // we are in a static/const initializer
-                self.mode != Mode::Var &&
-
-                // feature-gate is not enabled
-                !self.tcx.sess.features.borrow().const_fn &&
-
-                // this doesn't come from a macro that has #[allow_internal_unstable]
-                !self.tcx.sess.codemap().span_allows_unstable(expr.span)
-            {
-                self.tcx.sess.span_err(
-                    expr.span,
-                    &format!("const fns are an unstable feature"));
-                fileline_help!(
-                    self.tcx.sess,
-                    expr.span,
-                    "in Nightly builds, add `#![feature(const_fn)]` to the crate \
-                     attributes to enable");
-            }
-
             let qualif = self.fn_like(fn_like.kind(),
                                       fn_like.decl(),
                                       fn_like.body(),
@@ -273,13 +249,13 @@ impl<'a, 'tcx> CheckCrateVisitor<'a, 'tcx> {
         let suffix = if tcontents.has_dtor() {
             "destructors"
         } else if tcontents.owns_owned() {
-            "boxes"
+            "owned pointers"
         } else {
             return
         };
 
-        span_err!(self.tcx.sess, e.span, E0397,
-                 "mutable statics are not allowed to have {}", suffix);
+        self.tcx.sess.span_err(e.span, &format!("mutable statics are not allowed \
+                                                 to have {}", suffix));
     }
 
     fn check_static_type(&self, e: &ast::Expr) {
@@ -681,7 +657,7 @@ fn check_expr<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>,
                 }
                 Some(def::DefMethod(did, def::FromImpl(_))) |
                 Some(def::DefFn(did, _)) => {
-                    v.handle_const_fn_call(e, did, node_ty)
+                    v.handle_const_fn_call(did, node_ty)
                 }
                 _ => false
             };
@@ -701,7 +677,7 @@ fn check_expr<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>,
                 _ => None
             };
             let is_const = match method_did {
-                Some(did) => v.handle_const_fn_call(e, did, node_ty),
+                Some(did) => v.handle_const_fn_call(did, node_ty),
                 None => false
             };
             if !is_const {

branches/tmp/src/librustc_trans/lib.rs

@@ -30,7 +30,6 @@
 #![feature(box_syntax)]
 #![feature(collections)]
 #![feature(core)]
-#![feature(const_fn)]
 #![feature(libc)]
 #![feature(quote)]
 #![feature(rustc_diagnostic_macros)]