Auto merge of rust-lang#21582 - FlaPer87:rollup, r=brson

- Successful merges: rust-lang#21108, rust-lang#21445, rust-lang#21498, rust-lang#21504, rust-lang#21532, rust-lang#21535, rust-lang#21539, rust-lang#21540, rust-lang#21541, rust-lang#21550, rust-lang#21560, rust-lang#21573, rust-lang#21579 - Failed merges:

Author: bors

configure

@@ -28,8 +28,8 @@ need_ok() {
 
 need_cmd() {
  if command -v $1 >/dev/null 2>&1
- then msg "found $1"
- else err "need $1"
+ then msg "found program $1"
+ else err "need program $1"
  fi
 }
 
@@ -340,6 +340,7 @@ need_cmd date
 need_cmd tr
 need_cmd sed
 need_cmd file
+need_cmd make
 
 msg "inspecting environment"
 

mk/main.mk

@@ -30,8 +30,8 @@ CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)
 CFG_DISABLE_UNSTABLE_FEATURES=1
 endif
 ifeq ($(CFG_RELEASE_CHANNEL),beta)
-CFG_RELEASE=$(CFG_RELEASE_NUM)-beta(CFG_PRERELEASE_VERSION)
-CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)-beta(CFG_PRERELEASE_VERSION)
+CFG_RELEASE=$(CFG_RELEASE_NUM)-beta$(CFG_PRERELEASE_VERSION)
+CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)-beta$(CFG_PRERELEASE_VERSION)
 CFG_DISABLE_UNSTABLE_FEATURES=1
 endif
 ifeq ($(CFG_RELEASE_CHANNEL),nightly)

src/compiletest/common.rs

@@ -12,6 +12,20 @@ pub use self::Mode::*;
 use std::fmt;
 use std::str::FromStr;
 
+#[cfg(stage0)] // NOTE: remove impl after snapshot
+#[derive(Clone, PartialEq, Show)]
+pub enum Mode {
+ CompileFail,
+ RunFail,
+ RunPass,
+ RunPassValgrind,
+ Pretty,
+ DebugInfoGdb,
+ DebugInfoLldb,
+ Codegen
+}
+
+#[cfg(not(stage0))] // NOTE: remove cfg after snapshot
 #[derive(Clone, PartialEq, Debug)]
 pub enum Mode {
  CompileFail,
@@ -24,6 +38,7 @@ pub enum Mode {
  Codegen
 }
 
+
 impl Copy for Mode {}
 
 impl FromStr for Mode {

src/doc/reference.md

@@ -2291,136 +2291,7 @@ The name `str_eq` has a special meaning to the Rust compiler, and the presence
 of this definition means that it will use this definition when generating calls
 to the string equality function.
 
-A complete list of the built-in language items follows:
-
-#### Built-in Traits
-
-* `copy`
- : Types that do not move ownership when used by-value.
-* `drop`
- : Have destructors.
-* `send`
- : Able to be sent across thread boundaries.
-* `sized`
- : Has a size known at compile time.
-* `sync`
- : Able to be safely shared between threads when aliased.
-
-#### Operators
-
-These language items are traits:
-
-* `add`
- : Elements can be added (for example, integers and floats).
-* `sub`
- : Elements can be subtracted.
-* `mul`
- : Elements can be multiplied.
-* `div`
- : Elements have a division operation.
-* `rem`
- : Elements have a remainder operation.
-* `neg`
- : Elements can be negated arithmetically.
-* `not`
- : Elements can be negated logically.
-* `bitxor`
- : Elements have an exclusive-or operation.
-* `bitand`
- : Elements have a bitwise `and` operation.
-* `bitor`
- : Elements have a bitwise `or` operation.
-* `shl`
- : Elements have a left shift operation.
-* `shr`
- : Elements have a right shift operation.
-* `index`
- : Elements can be indexed.
-* `index_mut`
- : ___Needs filling in___
-* `eq`
- : Elements can be compared for equality.
-* `ord`
- : Elements have a partial ordering.
-* `deref`
- : `*` can be applied, yielding a reference to another type.
-* `deref_mut`
- : `*` can be applied, yielding a mutable reference to another type.
-
-These are functions:
-
-* `fn`
- : ___Needs filling in___
-* `fn_mut`
- : ___Needs filling in___
-* `fn_once`
- : ___Needs filling in___
-* `str_eq`
- : Compare two strings (`&str`) for equality.
-* `strdup_uniq`
- : Return a new unique string
- containing a copy of the contents of a unique string.
-
-#### Types
-
-* `type_id`
- : The type returned by the `type_id` intrinsic.
-* `unsafe`
- : A type whose contents can be mutated through an immutable reference.
-
-#### Marker types
-
-These types help drive the compiler's analysis
-
-* `begin_unwind`
- : ___Needs filling in___
-* `no_copy_bound`
- : This type does not implement "copy", even if eligible.
-* `eh_personality`
- : ___Needs filling in___
-* `exchange_free`
- : Free memory that was allocated on the exchange heap.
-* `exchange_malloc`
- : Allocate memory on the exchange heap.
-* `closure_exchange_malloc`
- : ___Needs filling in___
-* `panic`
- : Abort the program with an error.
-* `fail_bounds_check`
- : Abort the program with a bounds check error.
-* `free`
- : Free memory that was allocated on the managed heap.
-* `gc`
- : ___Needs filling in___
-* `exchange_heap`
- : ___Needs filling in___
-* `iterator`
- : ___Needs filling in___
-* `contravariant_lifetime`
- : The lifetime parameter should be considered contravariant.
-* `covariant_lifetime`
- : The lifetime parameter should be considered covariant.
-* `invariant_lifetime`
- : The lifetime parameter should be considered invariant.
-* `malloc`
- : Allocate memory on the managed heap.
-* `owned_box`
- : ___Needs filling in___
-* `stack_exhausted`
- : ___Needs filling in___
-* `start`
- : ___Needs filling in___
-* `contravariant_type`
- : The type parameter should be considered contravariant.
-* `covariant_type`
- : The type parameter should be considered covariant.
-* `invariant_type`
- : The type parameter should be considered invariant.
-* `ty_desc`
- : ___Needs filling in___
-
-> **Note:** This list is likely to become out of date. We should auto-generate
-> it from `librustc/middle/lang_items.rs`.
+A complete list of the built-in language items will be added in the future.
 
 ### Inline attributes
 
@@ -2652,9 +2523,7 @@ The currently implemented features of the reference compiler are:
  declare a `static` as being unique per-thread leveraging
  LLVM's implementation which works in concert with the kernel
  loader and dynamic linker. This is not necessarily available
- on all platforms, and usage of it is discouraged (rust
- focuses more on thread-local data instead of thread-local
- data).
+ on all platforms, and usage of it is discouraged.
 
 * `trace_macros` - Allows use of the `trace_macros` macro, which is a nasty
  hack that will certainly be removed.

src/doc/trpl/installing-rust.md

@@ -83,7 +83,6 @@ If not, there are a number of places where you can get help. The easiest is
 you can access through
 [Mibbit](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust). Click
 that link, and you'll be chatting with other Rustaceans (a silly nickname we
-call ourselves), and we can help you out. Other great resources include [our
-forum](http://discuss.rust-lang.org/), [the /r/rust
-subreddit](http://www.reddit.com/r/rust), and [Stack
+call ourselves), and we can help you out. Other great resources include [the
+/r/rust subreddit](http://www.reddit.com/r/rust), and [Stack
 Overflow](http://stackoverflow.com/questions/tagged/rust).

src/doc/trpl/method-syntax.md

@@ -18,6 +18,8 @@ x.foo().bar().baz();
 Luckily, as you may have guessed with the leading question, you can! Rust provides
 the ability to use this *method call syntax* via the `impl` keyword.
 
+## Method calls
+
 Here's how it works:
 
 ```{rust}
@@ -56,11 +58,56 @@ other parameter. Because we know it's a `Circle`, we can access the `radius`
 just like we would with any other struct. An import of π and some
 multiplications later, and we have our area.
 
+## Chaining method calls
+
+So, now we know how to call a method, such as `foo.bar()`. But what about our
+original example, `foo.bar().baz()`? This is called 'method chaining', and we
+can do it by returning `self`.
+
+```
+struct Circle {
+ x: f64,
+ y: f64,
+ radius: f64,
+}
+
+impl Circle {
+ fn area(&self) -> f64 {
+ std::f64::consts::PI * (self.radius * self.radius)
+ }
+
+ fn grow(&self) -> Circle {
+ Circle { x: self.x, y: self.y, radius: (self.radius * 10.0) }
+ }
+}
+
+fn main() {
+ let c = Circle { x: 0.0, y: 0.0, radius: 2.0 };
+ println!("{}", c.area());
+
+ let d = c.grow().area();
+ println!("{}", d);
+}
+```
+
+Check the return type:
+
+```
+# struct Circle;
+# impl Circle {
+fn grow(&self) -> Circle {
+# Circle } }
+```
+
+We just say we're returning a `Circle`. With this, we can grow a new circle
+that's twice as big as the old one.
+
+## Static methods
+
 You can also define methods that do not take a `self` parameter. Here's a
 pattern that's very common in Rust code:
 
-```{rust}
-# #![allow(non_shorthand_field_patterns)]
+```
 struct Circle {
  x: f64,
  y: f64,
@@ -86,3 +133,66 @@ This *static method* builds a new `Circle` for us. Note that static methods
 are called with the `Struct::method()` syntax, rather than the `ref.method()`
 syntax.
 
+## Builder Pattern
+
+Let's say that we want our users to be able to create Circles, but we will
+allow them to only set the properties they care about. Otherwise, the `x`
+and `y` attributes will be `0.0`, and the `radius` will be `1.0`. Rust doesn't
+have method overloading, named arguments, or variable arguments. We employ
+the builder pattern instead. It looks like this:
+
+```
+struct Circle {
+ x: f64,
+ y: f64,
+ radius: f64,
+}
+
+impl Circle {
+ fn area(&self) -> f64 {
+ std::f64::consts::PI * (self.radius * self.radius)
+ }
+}
+
+struct CircleBuilder {
+ coordinate: f64,
+ radius: f64,
+}
+
+impl CircleBuilder {
+ fn new() -> CircleBuilder {
+ CircleBuilder { coordinate: 0.0, radius: 0.0, }
+ }
+
+ fn coordinate(&mut self, coordinate: f64) -> &mut CircleBuilder {
+self.coordinate = coordinate;
+self
+ }
+
+ fn radius(&mut self, radius: f64) -> &mut CircleBuilder {
+self.radius = radius;
+self
+ }
+
+ fn finalize(&self) -> Circle {
+ Circle { x: self.coordinate, y: self.coordinate, radius: self.radius }
+ }
+}
+
+fn main() {
+ let c = CircleBuilder::new()
+ .coordinate(10.0)
+ .radius(5.0)
+ .finalize();
+
+
+ println!("area: {}", c.area());
+}
+```
+
+What we've done here is make another struct, `CircleBuilder`. We've defined our
+builder methods on it. We've also defined our `area()` method on `Circle`. We
+also made one more method on `CircleBuilder`: `finalize()`. This method creates
+our final `Circle` from the builder. Now, we've used the type system to enforce
+our concerns: we can use the methods on `CircleBuilder` to constrain making
+`Circle`s in any way we choose.