---

yaml
---
r: 235464
b: refs/heads/stable
c: 98f2872
h: refs/heads/master
v: v3

Author: AlisdairO

[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: 1da1a46d563135233dec770abbe67fccc70bd434
+refs/heads/stable: 98f287240ff9518c1ea5519c5cd03dc2ba6d4452
 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/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));
 }
 ```
 

branches/stable/src/doc/trpl/the-stack-and-the-heap.md

@@ -176,7 +176,7 @@ After `bar()` is over, its frame is deallocated, leaving just `foo()` and
 | 1       | a    | 5     |
 | 0       | x    | 42    |
 
-And then `foo()` ends, leaving just `main()`:
+And then `foo()` ends, leaving just `main()`
 
 | Address | Name | Value |
 |---------|------|-------|
@@ -537,7 +537,7 @@ Generally, you should prefer stack allocation, and so, Rust stack-allocates by
 default. The LIFO model of the stack is simpler, at a fundamental level. This
 has two big impacts: runtime efficiency and semantic impact.
 
-## Runtime Efficiency
+## Runtime Efficiency.
 
 Managing the memory for the stack is trivial: The machine just
 increments or decrements a single value, the so-called “stack pointer”.

branches/stable/src/librustc/diagnostics.rs

@@ -972,16 +972,16 @@ Updates to the borrow checker in a future version of Rust may remove this
 restriction, but for now patterns must be rewritten without sub-bindings.
 
 ```
-// Before.
-match Some("hi".to_string()) {
-    ref op_string_ref @ Some(ref s) => ...
+// Code like this...
+match Some(5) {
+    ref op_num @ Some(num) => ...
     None => ...
 }
 
 // After.
 match Some("hi".to_string()) {
     Some(ref s) => {
-        let op_string_ref = &Some(s);
+        let op_string_ref = &Some(&s);
         ...
     }
     None => ...

branches/stable/src/librustc_borrowck/borrowck/mod.rs

@@ -705,19 +705,8 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
                             ol,
                             moved_lp_msg,
                             pat_ty));
-                match self.tcx.sess.codemap().span_to_snippet(span) {
-                    Ok(string) => {
-                        self.tcx.sess.span_suggestion(
-                            span,
-                            &format!("if you would like to borrow the value instead, \
-                                      use a `ref` binding as shown:"),
-                            format!("ref {}", string));
-                    },
-                    Err(_) => {
-                        self.tcx.sess.fileline_help(span,
-                            "use `ref` to override");
-                    },
-                }
+                self.tcx.sess.fileline_help(span,
+                    "use `ref` to override");
             }
 
             move_data::Captured => {

branches/stable/src/librustc_resolve/build_reduced_graph.rs

@@ -26,7 +26,6 @@ use ParentLink::{self, ModuleParentLink, BlockParentLink};
 use Resolver;
 use resolve_imports::Shadowable;
 use TypeNsDef;
-use {resolve_error, ResolutionError};
 
 use self::DuplicateCheckingMode::*;
 use self::NamespaceError::*;
@@ -209,13 +208,10 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> {
                     // Return an error here by looking up the namespace that
                     // had the duplicate.
                     let ns = ns.unwrap();
-                    resolve_error(
-                        self,
-                        sp,
-                        ResolutionError::DuplicateDefinition(
-                            namespace_error_to_string(duplicate_type),
-                            name)
-                    );
+                    self.resolve_error(sp,
+                        &format!("duplicate definition of {} `{}`",
+                             namespace_error_to_string(duplicate_type),
+                             token::get_name(name)));
                     {
                         let r = child.span_for_namespace(ns);
                         if let Some(sp) = r {
@@ -308,10 +304,8 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> {
                             full_path.segments.last().unwrap().identifier.name;
                         if &token::get_name(source_name)[..] == "mod" ||
                            &token::get_name(source_name)[..] == "self" {
-                            resolve_error(self,
-                                            view_path.span,
-                                            ResolutionError::SelfImportsOnlyAllowedWithin
-                            );
+                            self.resolve_error(view_path.span,
+                                "`self` imports are only allowed within a { } list");
                         }
 
                         let subclass = SingleImport(binding.name,
@@ -331,11 +325,8 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> {
                             _ => None
                         }).collect::<Vec<Span>>();
                         if mod_spans.len() > 1 {
-                            resolve_error(
-                                self,
-                                mod_spans[0],
-                                ResolutionError::SelfImportCanOnlyAppearOnceInTheList
-                            );
+                            self.resolve_error(mod_spans[0],
+                                "`self` import can only appear once in the list");
                             for other_span in mod_spans.iter().skip(1) {
                                 self.session.span_note(*other_span,
                                     "another `self` import appears here");
@@ -350,12 +341,9 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> {
                                     let name = match module_path.last() {
                                         Some(name) => *name,
                                         None => {
-                                            resolve_error(
-                                                self,
-                                                source_item.span,
-                                                ResolutionError::
-                                                SelfImportOnlyInImportListWithNonEmptyPrefix
-                                            );
+                                            self.resolve_error(source_item.span,
+                                                "`self` import can only appear in an import list \
+                                                 with a non-empty prefix");
                                             continue;
                                         }
                                     };

branches/stable/src/librustc_resolve/diagnostics.rs

@@ -202,52 +202,12 @@ http://doc.rust-lang.org/reference.html#types
 }
 
 register_diagnostics! {
-    E0153, // called no where
-    E0157, // called from no where
+    E0157,
+    E0153,
     E0253, // not directly importable
     E0254, // import conflicts with imported crate in this module
     E0257,
     E0258,
     E0364, // item is private
-    E0365, // item is private
-    E0401, // can't use type parameters from outer function
-    E0402, // cannot use an outer type parameter in this context
-    E0403, // the name `{}` is already used
-    E0404, // is not a trait
-    E0405, // use of undeclared trait name
-    E0406, // undeclared associated type
-    E0407, // method is not a member of trait
-    E0408, // variable from pattern #1 is not bound in pattern #
-    E0409, // variable is bound with different mode in pattern # than in
-           // pattern #1
-    E0410, // variable from pattern is not bound in pattern 1
-    E0411, // use of `Self` outside of an impl or trait
-    E0412, // use of undeclared
-    E0413, // declaration of shadows an enum variant or unit-like struct in
-           // scope
-    E0414, // only irrefutable patterns allowed here
-    E0415, // identifier is bound more than once in this parameter list
-    E0416, // identifier is bound more than once in the same pattern
-    E0417, // static variables cannot be referenced in a pattern, use a
-           // `const` instead
-    E0418, // is not an enum variant, struct or const
-    E0419, // unresolved enum variant, struct or const
-    E0420, // is not an associated const
-    E0421, // unresolved associated const
-    E0422, // does not name a structure
-    E0423, // is a struct variant name, but this expression uses it like a
-           // function name
-    E0424, // `self` is not available in a static method.
-    E0425, // unresolved name
-    E0426, // use of undeclared label
-    E0427, // cannot use `ref` binding mode with ...
-    E0428, // duplicate definition of ...
-    E0429, // `self` imports are only allowed within a { } list
-    E0430, // `self` import can only appear once in the list
-    E0431, // `self` import can only appear in an import list with a non-empty
-           // prefix
-    E0432, // unresolved import
-    E0433, // failed to resolve
-    E0434, // can't capture dynamic environment in a fn item
-    E0435  // attempt to use a non-constant value in a constant
+    E0365  // item is private
 }