---

yaml
---
r: 182719
b: refs/heads/beta
c: 0dac568
h: refs/heads/master
i:
  182717: f8b428f
  182715: 36130f4
  182711: 6f2d172
  182703: 29c0589
  182687: 389493a
  182655: 8e96d1e
v: v3

Author: alexcrichton

[refs]

@@ -31,7 +31,7 @@ refs/heads/automation-fail: 1bf06495443584539b958873e04cc2f864ab10e4
 refs/heads/issue-18208-method-dispatch-3-quick-reject: 2009f85b9f99dedcec4404418eda9ddba90258a2
 refs/heads/batch: b7fd822592a4fb577552d93010c4a4e14f314346
 refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
-refs/heads/beta: 16286f5cf921a9de463d8a744c33f49837698c3d
+refs/heads/beta: 0dac5685783631dc4ecf3e865229a3747fe81943
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: eb836bf767aa1d8d4cba488a9091cde3c0ab4b2f

branches/beta/configure

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

branches/beta/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)

branches/beta/src/compiletest/common.rs

@@ -12,20 +12,6 @@ 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,
@@ -38,7 +24,6 @@ pub enum Mode {
     Codegen
 }
 
-
 impl Copy for Mode {}
 
 impl FromStr for Mode {

branches/beta/src/doc/reference.md

@@ -2291,7 +2291,136 @@ 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 will be added in the future.
+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`.
 
 ### Inline attributes
 
@@ -2489,6 +2618,10 @@ The currently implemented features of the reference compiler are:
                        for now until the specification of identifiers is fully
                        fleshed out.
 
+* `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.
+
 * `plugin` - Usage of [compiler plugins][plugin] for custom lints or syntax extensions.
              These depend on compiler internals and are subject to change.
 
@@ -2519,7 +2652,9 @@ 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.
+                   on all platforms, and usage of it is discouraged (rust
+                   focuses more on thread-local data instead of thread-local
+                   data).
 
 * `trace_macros` - Allows use of the `trace_macros` macro, which is a nasty
                    hack that will certainly be removed.

branches/beta/src/doc/trpl/installing-rust.md

@@ -83,6 +83,7 @@ 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 [the
-/r/rust subreddit](http://www.reddit.com/r/rust), and [Stack
+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
 Overflow](http://stackoverflow.com/questions/tagged/rust).

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

@@ -18,8 +18,6 @@ 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}
@@ -58,56 +56,11 @@ 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,
@@ -133,66 +86,3 @@ 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.