---

yaml
---
r: 235509
b: refs/heads/stable
c: 2d32a15
h: refs/heads/master
i:
  235507: cba0e40
v: v3

Author: soderstroff

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: afae2ff723393b3ab4ccffef6ac7c6d1809e2da0
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: f859507de8c410b648d934d8f5ec1c52daac971d
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: 07b337ce33c6c555ce9ff1ad7f97f4acc8434c05
+refs/heads/stable: 2d32a15667c6d04db96938d1e3e56db34c0a9415
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/.travis.yml

@@ -1,38 +1,20 @@
-# ccache support is disabled unless your language is a C-derivative. However
-# `language: C` unconditionally sets `CC=compiler`. If we just set it in our
-# `env` it will be overwritten by the default (gcc 4.6).
+# Use something that's not 'ruby' so we don't set up things like
+# RVM/bundler/ruby and whatnot. Right now 'rust' as a language actually
+# downloads a rust/cargo snapshot, which we don't really want for building rust.
 language: c
-compiler: /usr/bin/gcc-4.7
-cache: ccache
 sudo: false
 
 # The test suite is in general way too stressful for travis, especially in
 # terms of time limit and reliability. In the past we've tried to scale things
 # back to only build the stage1 compiler and run a subset of tests, but this
 # didn't end up panning out very well.
 #
-# As a result, we're just using travis to run `make tidy` and *only* build
-# stage1 but *not* test it for now (a strict subset of the bootstrap). This will
-# catch "obvious" errors like style or not even compiling.
-#
-# We need gcc4.7 or higher to build LLVM, and travis (well, Ubuntu 12.04)
-# currently ships with 4.6. Gotta download our own.
+# As a result, we're just using travis to run `make tidy` now. It'll help
+# everyone find out about their trailing spaces early on!
 before_script:
-  - ./configure --enable-ccache
+  - ./configure --llvm-root=path/to/nowhere
 script:
   - make tidy
-  - make rustc-stage1 -j4
-
-env:
-  - CXX=/usr/bin/g++-4.7
-
-addons:
-  apt:
-    sources:
-    - ubuntu-toolchain-r-test
-    packages:
-    - gcc-4.7
-    - g++-4.7
 
 # Real testing happens on http://buildbot.rust-lang.org/
 #

branches/stable/CONTRIBUTING.md

@@ -133,8 +133,8 @@ Documentation improvements are very welcome. The source of `doc.rust-lang.org`
 is located in `src/doc` in the tree, and standard API documentation is generated
 from the source code itself.
 
-Documentation pull requests function in the same way as other pull requests,
-though you may see a slightly different form of `r+`:
+Documentation pull requests function in the same as other pull requests, though
+you may see a slightly different form of `r+`:
 
     @bors: r+ 38fe8d2 rollup
 

branches/stable/RELEASES.md

@@ -28,9 +28,6 @@ Breaking Changes
   in, and the same value reported by clang's
   `alignof`. [`mem::min_align_of`] is deprecated. This is not known to
   break real code.
-* [The `#[packed]` attribute is no longer silently accepted by the
-  compiler][packed]. This attribute did nothing and code that
-  mentioned it likely did not work as intended.
 
 Language
 --------
@@ -143,7 +140,7 @@ Misc
 [fat]: https://github.com/rust-lang/rust/pull/26411
 [dst]: https://github.com/rust-lang/rfcs/blob/master/text/0982-dst-coercion.md
 [parcodegen]: https://github.com/rust-lang/rust/pull/26018
-[packed]: https://github.com/rust-lang/rust/pull/25541
+
 
 Version 1.1.0 (June 2015)
 =========================

branches/stable/configure

@@ -1031,12 +1031,15 @@ fi
 
 if [ ! -z "$CFG_ENABLE_CCACHE" ]
 then
-    if [ -z "$CFG_CCACHE" ]
+    if [ -z "$CC" ]
     then
-        err "ccache requested but not found"
-    fi
+        if [ -z "$CFG_CCACHE" ]
+        then
+            err "ccache requested but not found"
+        fi
 
-    CFG_CC="ccache $CFG_CC"
+        CFG_CC="ccache $CFG_CC"
+    fi
 fi
 
 if [ -z "$CC" -a -z "$CFG_ENABLE_CLANG" -a -z "$CFG_GCC" ]
@@ -1525,26 +1528,11 @@ do
 
             (*)
             msg "inferring LLVM_CXX/CC from CXX/CC = $CXX/$CC"
-            if [ ! -z "$CFG_ENABLE_CCACHE" ]
-            then
-                if [ -z "$CFG_CCACHE" ]
-                then
-                    err "ccache requested but not found"
-                fi
-
-                LLVM_CXX_32="ccache $CXX"
-                LLVM_CC_32="ccache $CC"
-
-                LLVM_CXX_64="ccache $CXX"
-                LLVM_CC_64="ccache $CC"
-            else
-                LLVM_CXX_32="$CXX"
-                LLVM_CC_32="$CC"
-
-                LLVM_CXX_64="$CXX"
-                LLVM_CC_64="$CC"
-            fi
+            LLVM_CXX_32="$CXX"
+            LLVM_CC_32="$CC"
 
+            LLVM_CXX_64="$CXX"
+            LLVM_CC_64="$CC"
             ;;
         esac
 

branches/stable/src/doc/reference.md

@@ -343,10 +343,10 @@ The type of an _unsuffixed_ integer literal is determined by type inference:
 * If an integer type can be _uniquely_ determined from the surrounding
   program context, the unsuffixed integer literal has that type.
 
-* If the program context under-constrains the type, it defaults to the
+* If the program context underconstrains the type, it defaults to the
   signed 32-bit integer `i32`.
 
-* If the program context over-constrains the type, it is considered a
+* If the program context overconstrains the type, it is considered a
   static type error.
 
 Examples of integer literals of various forms:
@@ -382,9 +382,9 @@ type inference:
   surrounding program context, the unsuffixed floating-point literal
   has that type.
 
-* If the program context under-constrains the type, it defaults to `f64`.
+* If the program context underconstrains the type, it defaults to `f64`.
 
-* If the program context over-constrains the type, it is considered a
+* If the program context overconstrains the type, it is considered a
   static type error.
 
 Examples of floating-point literals of various forms:
@@ -1292,7 +1292,7 @@ All access to a static is safe, but there are a number of restrictions on
 statics:
 
 * Statics may not contain any destructors.
-* The types of static values must ascribe to `Sync` to allow thread-safe access.
+* The types of static values must ascribe to `Sync` to allow threadsafe access.
 * Statics may not refer to other statics by value, only by reference.
 * Constants cannot refer to statics.
 
@@ -1694,7 +1694,7 @@ explain, here's a few use cases and what they would entail:
 * A crate needs a global available "helper module" to itself, but it doesn't
   want to expose the helper module as a public API. To accomplish this, the
   root of the crate's hierarchy would have a private module which then
-  internally has a "public API". Because the entire crate is a descendant of
+  internally has a "public api". Because the entire crate is a descendant of
   the root, then the entire local crate can access this private module through
   the second case.
 
@@ -1957,6 +1957,8 @@ macro scope.
   object file that this item's contents will be placed into.
 - `no_mangle` - on any item, do not apply the standard name mangling. Set the
   symbol for this item to its identifier.
+- `packed` - on structs or enums, eliminate any padding that would be used to
+  align fields.
 - `simd` - on certain tuple structs, derive the arithmetic operators, which
   lower to the target's SIMD instructions, if any; the `simd` feature gate
   is necessary to use this attribute.
@@ -3661,71 +3663,47 @@ sites are:
 
 * `let` statements where an explicit type is given.
 
-   For example, `128` is coerced to have type `i8` in the following:
-
-   ```rust
-   let _: i8 = 128;
-   ```
+    In `let _: U = e;`, `e` is coerced to have type `U`.
 
 * `static` and `const` statements (similar to `let` statements).
 
-* Arguments for function calls
-
-  The value being coerced is the actual parameter, and it is coerced to
-  the type of the formal parameter.
-
-  For example, `128` is coerced to have type `i8` in the following:
-
-  ```rust
-  fn bar(_: i8) { }
+* arguments for function calls.
 
-  fn main() {
-     bar(128);
-  }
-  ```
+    The value being coerced is the
+    actual parameter and it is coerced to the type of the formal parameter. For
+    example, let `foo` be defined as `fn foo(x: U) { ... }` and call it as
+    `foo(e);`. Then `e` is coerced to have type `U`;
 
-* Instantiations of struct or variant fields
+* instantiations of struct or variant fields.
 
-  For example, `128` is coerced to have type `i8` in the following:
+    Assume we have a `struct
+    Foo { x: U }` and instantiate it as `Foo { x: e }`. Then `e` is coerced to
+    have type `U`.
 
-  ```rust
-  struct Foo { x: i8 }
+* function results (either the final line of a block if it is not semicolon
+terminated or any expression in a `return` statement).
 
-  fn main() {
-      Foo { x: 128 };
-  }
-  ```
-
-* Function results, either the final line of a block if it is not
-  semicolon-terminated or any expression in a `return` statement
-
-  For example, `128` is coerced to have type `i8` in the following:
-
-  ```rust
-  fn foo() -> i8 {
-      128
-  }
-  ```
+    In `fn foo() -> U { e }`, `e` is coerced to to have type `U`.
 
 If the expression in one of these coercion sites is a coercion-propagating
 expression, then the relevant sub-expressions in that expression are also
 coercion sites. Propagation recurses from these new coercion sites.
 Propagating expressions and their relevant sub-expressions are:
 
-* Array literals, where the array has type `[U; n]`. Each sub-expression in
+* array literals, where the array has type `[U; n]`. Each sub-expression in
 the array literal is a coercion site for coercion to type `U`.
 
-* Array literals with repeating syntax, where the array has type `[U; n]`. The
+* array literals with repeating syntax, where the array has type `[U; n]`. The
 repeated sub-expression is a coercion site for coercion to type `U`.
 
-* Tuples, where a tuple is a coercion site to type `(U_0, U_1, ..., U_n)`.
+* tuples, where a tuple is a coercion site to type `(U_0, U_1, ..., U_n)`.
 Each sub-expression is a coercion site to the respective type, e.g. the
 zeroth sub-expression is a coercion site to type `U_0`.
 
-* Parenthesised sub-expressions (`(e)`): if the expression has type `U`, then
+* parenthesised sub-expressions (`(e)`). If the expression has type `U`, then
 the sub-expression is a coercion site to `U`.
 
-* Blocks: if a block has type `U`, then the last expression in the block (if
+* blocks. If a block has type `U`, then the last expression in the block (if
 it is not semicolon-terminated) is a coercion site to `U`. This includes
 blocks which are part of control flow statements, such as `if`/`else`, if
 the block has a known type.
@@ -3734,46 +3712,45 @@ the block has a known type.
 
 Coercion is allowed between the following types:
 
-* `T` to `U` if `T` is a subtype of `U` (*reflexive case*)
+* `T` to `U` if `T` is a subtype of `U` (*reflexive case*).
 
 * `T_1` to `T_3` where `T_1` coerces to `T_2` and `T_2` coerces to `T_3`
-(*transitive case*)
+(*transitive case*).
 
     Note that this is not fully supported yet
 
-* `&mut T` to `&T`
+* `&mut T` to `&T`.
 
-* `*mut T` to `*const T`
+* `*mut T` to `*const T`.
 
-* `&T` to `*const T`
+* `&T` to `*const T`.
 
-* `&mut T` to `*mut T`
+* `&mut T` to `*mut T`.
 
 * `&T` to `&U` if `T` implements `Deref<Target = U>`. For example:
 
-  ```rust
-  use std::ops::Deref;
-
-  struct CharContainer {
-      value: char
-  }
+```rust
+use std::ops::Deref;
 
-  impl Deref for CharContainer {
-      type Target = char;
+struct CharContainer {
+    value: char
+}
 
-      fn deref<'a>(&'a self) -> &'a char {
-          &self.value
-      }
-  }
+impl Deref for CharContainer {
+    type Target = char;
 
-  fn foo(arg: &char) {}
+    fn deref<'a>(&'a self) -> &'a char {
+        &self.value
+    }
+}
 
-  fn main() {
-      let x = &mut CharContainer { value: 'y' };
-      foo(x); //&mut CharContainer is coerced to &char.
-  }
-  ```
+fn foo(arg: &char) {}
 
+fn main() {
+    let x = &mut CharContainer { value: 'y' };
+    foo(x); //&mut CharContainer is coerced to &char.
+}
+```
 * `&mut T` to `&mut U` if `T` implements `DerefMut<Target = U>`.
 
 * TyCtor(`T`) to TyCtor(coerce_inner(`T`)), where TyCtor(`T`) is one of
@@ -3987,7 +3964,7 @@ 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
+# Appendix: Rationales and design tradeoffs
 
 *TODO*.
 
@@ -3997,7 +3974,7 @@ Rust is not a particularly original language, with design elements coming from
 a wide range of sources. Some of these are listed below (including elements
 that have since been removed):
 
-* SML, OCaml: algebraic data types, pattern matching, type inference,
+* SML, OCaml: algebraic datatypes, pattern matching, type inference,
   semicolon statement separation
 * C++: references, RAII, smart pointers, move semantics, monomorphisation,
   memory model

branches/stable/src/doc/trpl/error-handling.md

@@ -50,8 +50,6 @@ is very wrong. Wrong enough that we can't continue with things in the current
 state. Another example is using the `unreachable!()` macro:
 
 ```rust,ignore
-use Event::NewRelease;
-
 enum Event {
     NewRelease,
 }
@@ -73,7 +71,7 @@ fn descriptive_probability(event: Event) -> &'static str {
 }
 
 fn main() {
-    println!("{}", descriptive_probability(NewRelease));
+    std::io::println(descriptive_probability(NewRelease));
 }
 ```