---

yaml
---
r: 236559
b: refs/heads/tmp
c: 081278e
h: refs/heads/master
i:
  236557: 1f42102
  236555: 92e3b9b
  236551: e120579
  236543: cbd7f6e
v: v3

Author: SimonSapin

[refs]

@@ -25,7 +25,7 @@ refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
 refs/heads/beta: d2e13e822a73e0ea46ae9e21afdd3155fc997f6d
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: aed73e0122e538375e6ef827e90c6d1a191c5fff
+refs/heads/tmp: 081278eb7acc761f583351e846ebad21c88331ff
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: f859507de8c410b648d934d8f5ec1c52daac971d
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828

branches/tmp/src/doc/grammar.md

@@ -9,7 +9,7 @@ provides only one kind of material:
 
 This document does not serve as an introduction to the language. Background
 familiarity with the language is assumed. A separate [guide] is available to
-help acquire such background.
+help acquire such background familiarity.
 
 This document also does not serve as a reference to the [standard] library
 included in the language distribution. Those libraries are documented

branches/tmp/src/doc/reference.md

@@ -674,7 +674,7 @@ There are several kinds of item:
 * [modules](#modules)
 * [functions](#functions)
 * [type definitions](grammar.html#type-definitions)
-* [structs](#structs)
+* [structures](#structures)
 * [enumerations](#enumerations)
 * [constant items](#constant-items)
 * [static items](#static-items)
@@ -900,10 +900,9 @@ fn main() {}
 
 ### Functions
 
-A _function item_ defines a sequence of [statements](#statements) and a
-final [expression](#expressions), along with a name and a set of
-parameters. Other than a name, all these are optional.
-Functions are declared with the keyword `fn`. Functions may declare a
+A _function item_ defines a sequence of [statements](#statements) and an
+optional final [expression](#expressions), along with a name and a set of
+parameters. Functions are declared with the keyword `fn`. Functions declare a
 set of *input* [*variables*](#variables) as parameters, through which the caller
 passes arguments into the function, and the *output* [*type*](#types)
 of the value the function will return to its caller on completion.
@@ -922,7 +921,7 @@ An example of a function:
 
 ```
 fn add(x: i32, y: i32) -> i32 {
-    x + y
+    return x + y;
 }
 ```
 
@@ -1156,7 +1155,7 @@ type Point = (u8, u8);
 let p: Point = (41, 68);
 ```
 
-### Structs
+### Structures
 
 A _structure_ is a nominal [structure type](#structure-types) defined with the
 keyword `struct`.
@@ -2615,21 +2614,21 @@ comma:
 ### Structure expressions
 
 There are several forms of structure expressions. A _structure expression_
-consists of the [path](#paths) of a [structure item](#structs), followed by
+consists of the [path](#paths) of a [structure item](#structures), followed by
 a brace-enclosed list of one or more comma-separated name-value pairs,
 providing the field values of a new instance of the structure. A field name
 can be any identifier, and is separated from its value expression by a colon.
 The location denoted by a structure field is mutable if and only if the
 enclosing structure is mutable.
 
 A _tuple structure expression_ consists of the [path](#paths) of a [structure
-item](#structs), followed by a parenthesized list of one or more
+item](#structures), followed by a parenthesized list of one or more
 comma-separated expressions (in other words, the path of a structure item
 followed by a tuple expression). The structure item must be a tuple structure
 item.
 
 A _unit-like structure expression_ consists only of the [path](#paths) of a
-[structure item](#structs).
+[structure item](#structures).
 
 The following are examples of structure expressions:
 
@@ -3146,7 +3145,7 @@ if` condition is evaluated. If all `if` and `else if` conditions evaluate to
 
 A `match` expression branches on a *pattern*. The exact form of matching that
 occurs depends on the pattern. Patterns consist of some combination of
-literals, destructured arrays or enum constructors, structs and tuples,
+literals, destructured arrays or enum constructors, structures and tuples,
 variable binding specifications, wildcards (`..`), and placeholders (`_`). A
 `match` expression has a *head expression*, which is the value to compare to
 the patterns. The type of the patterns must equal the type of the head
@@ -3470,7 +3469,7 @@ named reference to an [`enum` item](#enumerations).
 ### Recursive types
 
 Nominal types — [enumerations](#enumerated-types) and
-[structs](#structure-types) — may be recursive. That is, each `enum`
+[structures](#structure-types) — may be recursive. That is, each `enum`
 constructor or `struct` field may refer, directly or indirectly, to the
 enclosing `enum` or `struct` type itself. Such recursion has restrictions:
 
@@ -3498,7 +3497,7 @@ let a: List<i32> = List::Cons(7, Box::new(List::Cons(13, Box::new(List::Nil))));
 ### Pointer types
 
 All pointers in Rust are explicit first-class values. They can be copied,
-stored into data structs, and returned from functions. There are two
+stored into data structures, and returned from functions. There are two
 varieties of pointer in Rust:
 
 * References (`&`)
@@ -3898,7 +3897,7 @@ references to boxes are dropped.
 ### Variables
 
 A _variable_ is a component of a stack frame, either a named function parameter,
-an anonymous [temporary](#lvalues-rvalues-and-temporaries), or a named local
+an anonymous [temporary](#lvalues,-rvalues-and-temporaries), or a named local
 variable.
 
 A _local variable_ (or *stack-local* allocation) holds a value directly,
@@ -4037,6 +4036,10 @@ In general, `--crate-type=bin` or `--crate-type=lib` should be sufficient for
 all compilation needs, and the other options are just available if more
 fine-grained control is desired over the output format of a Rust crate.
 
+# Appendix: Rationales and design trade-offs
+
+*TODO*.
+
 # Appendix: Influences
 
 Rust is not a particularly original language, with design elements coming from

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

@@ -411,9 +411,8 @@ fn factory() -> &(Fn(i32) -> i32) {
 ```
 
 Right. Because we have a reference, we need to give it a lifetime. But
-our `factory()` function takes no arguments, so
-[elision](lifetimes.html#lifetime-elision) doesn’t kick in here. Then what
-choices do we have? Try `'static`:
+our `factory()` function takes no arguments, so elision doesn’t kick in
+here. What lifetime can we choose? `'static`:
 
 ```rust,ignore
 fn factory() -> &'static (Fn(i32) -> i32) {
@@ -433,7 +432,7 @@ But we get another error:
 ```text
 error: mismatched types:
  expected `&'static core::ops::Fn(i32) -> i32`,
-    found `[closure@<anon>:7:9: 7:20]`
+    found `[closure <anon>:7:9: 7:20]`
 (expected &-ptr,
     found closure) [E0308]
          |x| x + num
@@ -442,17 +441,21 @@ error: mismatched types:
 ```
 
 This error is letting us know that we don’t have a `&'static Fn(i32) -> i32`,
-we have a `[closure@<anon>:7:9: 7:20]`. Wait, what?
+we have a `[closure <anon>:7:9: 7:20]`. Wait, what?
 
 Because each closure generates its own environment `struct` and implementation
 of `Fn` and friends, these types are anonymous. They exist just solely for
-this closure. So Rust shows them as `closure@<anon>`, rather than some
+this closure. So Rust shows them as `closure <anon>`, rather than some
 autogenerated name.
 
-The error also points out that the return type is expected to be a reference,
-but what we are trying to return is not. Further, we cannot directly assign a
-`'static` lifetime to an object. So we'll take a different approach and return
-a "trait object" by `Box`ing up the `Fn`. This _almost_ works:
+But why doesn’t our closure implement `&'static Fn`? Well, as we discussed before,
+closures borrow their environment. And in this case, our environment is based
+on a stack-allocated `5`, the `num` variable binding. So the borrow has a lifetime
+of the stack frame. So if we returned this closure, the function call would be
+over, the stack frame would go away, and our closure is capturing an environment
+of garbage memory!
+
+So what to do? This _almost_ works:
 
 ```rust,ignore
 fn factory() -> Box<Fn(i32) -> i32> {
@@ -468,7 +471,7 @@ assert_eq!(6, answer);
 # }
 ```
 
-There’s just one last problem:
+We use a trait object, by `Box`ing up the `Fn`. There’s just one last problem:
 
 ```text
 error: closure may outlive the current function, but it borrows `num`,
@@ -477,12 +480,8 @@ Box::new(|x| x + num)
          ^~~~~~~~~~~
 ```
 
-Well, as we discussed before, closures borrow their environment. And in this
-case, our environment is based on a stack-allocated `5`, the `num` variable
-binding. So the borrow has a lifetime of the stack frame. So if we returned
-this closure, the function call would be over, the stack frame would go away,
-and our closure is capturing an environment of garbage memory! With one last
-fix, we can make this work:
+We still have a reference to the parent stack frame. With one last fix, we can
+make this work:
 
 ```rust
 fn factory() -> Box<Fn(i32) -> i32> {

branches/tmp/src/liballoc/boxed.rs

@@ -80,10 +80,11 @@ use core::raw::{TraitObject};
 /// use std::boxed::HEAP;
 ///
 /// fn main() {
-///     let foo: Box<i32> = in HEAP { 5 };
+///     let foo = box(HEAP) 5;
 ///     let foo = box 5;
 /// }
 /// ```
+#[lang = "exchange_heap"]
 #[unstable(feature = "box_heap",
            reason = "may be renamed; uncertain about custom allocator design",
            issue = "27779")]

branches/tmp/src/libcollections/binary_heap.rs

@@ -167,22 +167,12 @@ use vec::{self, Vec};
 /// item's ordering relative to any other item, as determined by the `Ord`
 /// trait, changes while it is in the heap. This is normally only possible
 /// through `Cell`, `RefCell`, global state, I/O, or unsafe code.
+#[derive(Clone)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct BinaryHeap<T> {
     data: Vec<T>,
 }
 
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Clone> Clone for BinaryHeap<T> {
-    fn clone(&self) -> Self {
-        BinaryHeap { data: self.data.clone() }
-    }
-
-    fn clone_from(&mut self, source: &Self) {
-        self.data.clone_from(&source.data);
-    }
-}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: Ord> Default for BinaryHeap<T> {
     #[inline]

branches/tmp/src/libcollections/lib.rs

@@ -62,7 +62,7 @@
 #![feature(unsafe_no_drop_flag, filling_drop)]
 #![feature(decode_utf16)]
 #![feature(utf8_error)]
-#![cfg_attr(test, feature(clone_from_slice, rand, test))]
+#![cfg_attr(test, feature(rand, test))]
 
 #![feature(no_std)]
 #![no_std]

branches/tmp/src/libcollections/string.rs

@@ -30,7 +30,7 @@ use vec::Vec;
 use boxed::Box;
 
 /// A growable string stored as a UTF-8 encoded buffer.
-#[derive(PartialOrd, Eq, Ord)]
+#[derive(Clone, PartialOrd, Eq, Ord)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct String {
     vec: Vec<u8>,
@@ -765,17 +765,6 @@ impl fmt::Display for FromUtf16Error {
     }
 }
 
-#[stable(feature = "rust1", since = "1.0.0")]
-impl Clone for String {
-    fn clone(&self) -> Self {
-        String { vec: self.vec.clone() }
-    }
-
-    fn clone_from(&mut self, source: &Self) {
-        self.vec.clone_from(&source.vec);
-    }
-}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl FromIterator<char> for String {
     fn from_iter<I: IntoIterator<Item=char>>(iterable: I) -> String {

branches/tmp/src/libcollections/vec.rs

@@ -1007,15 +1007,19 @@ impl<T:Clone> Clone for Vec<T> {
 
     fn clone_from(&mut self, other: &Vec<T>) {
         // drop anything in self that will not be overwritten
-        self.truncate(other.len());
-        let len = self.len();
+        if self.len() > other.len() {
+            self.truncate(other.len())
+        }
 
         // reuse the contained values' allocations/resources.
-        self.clone_from_slice(&other[..len]);
+        for (place, thing) in self.iter_mut().zip(other) {
+            place.clone_from(thing)
+        }
 
         // self.len <= other.len due to the truncate above, so the
         // slice here is always in-bounds.
-        self.push_all(&other[len..]);
+        let slice = &other[self.len()..];
+        self.push_all(slice);
     }
 }
 

branches/tmp/src/libcore/array.rs

@@ -35,23 +35,14 @@ use slice::{Iter, IterMut, SliceExt};
 ///
 /// This trait can be used to implement other traits on fixed-size arrays
 /// without causing much metadata bloat.
-///
-/// The trait is marked unsafe in order to restrict implementors to fixed-size
-/// arrays. User of this trait can assume that implementors have the exact
-/// layout in memory of a fixed size array (for example, for unsafe
-/// initialization).
-///
-/// Note that the traits AsRef and AsMut provide similar methods for types that
-/// may not be fixed-size arrays. Implementors should prefer those traits
-/// instead.
-pub unsafe trait FixedSizeArray<T> {
+pub trait FixedSizeArray<T> {
     /// Converts the array to immutable slice
     fn as_slice(&self) -> &[T];
     /// Converts the array to mutable slice
     fn as_mut_slice(&mut self) -> &mut [T];
 }
 
-unsafe impl<T, A: Unsize<[T]>> FixedSizeArray<T> for A {
+impl<T, A: Unsize<[T]>> FixedSizeArray<T> for A {
     #[inline]
     fn as_slice(&self) -> &[T] {
         self

branches/tmp/src/libcore/mem.rs

@@ -434,11 +434,6 @@ pub fn replace<T>(dest: &mut T, mut src: T) -> T {
 /// While this does call the argument's implementation of `Drop`, it will not
 /// release any borrows, as borrows are based on lexical scope.
 ///
-/// This effectively does nothing for
-/// [types which implement `Copy`](../../book/ownership.html#copy-types),
-/// e.g. integers. Such values are copied and _then_ moved into the function,
-/// so the value persists after this function call.
-///
 /// # Examples
 ///
 /// Basic usage:
@@ -491,21 +486,6 @@ pub fn replace<T>(dest: &mut T, mut src: T) -> T {
 /// let borrow = x.borrow();
 /// println!("{}", *borrow);
 /// ```
-///
-/// Integers and other types implementing `Copy` are unaffected by `drop()`
-///
-/// ```
-/// #[derive(Copy, Clone)]
-/// struct Foo(u8);
-///
-/// let x = 1;
-/// let y = Foo(2);
-/// drop(x); // a copy of `x` is moved and dropped
-/// drop(y); // a copy of `y` is moved and dropped
-///
-/// println!("x: {}, y: {}", x, y.0); // still available
-/// ```
-///
 #[inline]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub fn drop<T>(_x: T) { }

branches/tmp/src/libcore/str/mod.rs

@@ -115,8 +115,8 @@ impl Utf8Error {
     /// Returns the index in the given string up to which valid UTF-8 was
     /// verified.
     ///
-    /// Starting at the index provided, but not necessarily at it precisely, an
-    /// invalid UTF-8 encoding sequence was found.
+    /// It is the maximum index such that `from_utf8(input[..index])`
+    /// would return `Some(_)`.
     #[unstable(feature = "utf8_error", reason = "method just added",
                issue = "27734")]
     pub fn valid_up_to(&self) -> usize { self.valid_up_to }

branches/tmp/src/librustc/middle/cfg/construct.rs

@@ -344,12 +344,13 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
                 self.straightline(expr, pred, [r, l].iter().map(|&e| &**e))
             }
 
+            hir::ExprBox(Some(ref l), ref r) |
             hir::ExprIndex(ref l, ref r) |
             hir::ExprBinary(_, ref l, ref r) => { // NB: && and || handled earlier
                 self.straightline(expr, pred, [l, r].iter().map(|&e| &**e))
             }
 
-            hir::ExprBox(ref e) |
+            hir::ExprBox(None, ref e) |
             hir::ExprAddrOf(_, ref e) |
             hir::ExprCast(ref e, _) |
             hir::ExprUnary(_, ref e) |

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

@@ -568,7 +568,8 @@ fn check_expr<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>,
                             "user-defined operators are not allowed in {}s", v.msg());
             }
         }
-        hir::ExprBox(_) => {
+        hir::ExprBox(..) |
+        hir::ExprUnary(hir::UnUniq, _) => {
             v.add_qualif(ConstQualif::NOT_CONST);
             if v.mode != Mode::Var {
                 span_err!(v.tcx.sess, e.span, E0010,