---

yaml
---
r: 274335
b: refs/heads/stable
c: 727f959
h: refs/heads/master
i:
  274333: db120cf
  274331: c63a9ee
  274327: ddfc178
  274319: d68f924
  274303: f7c60b7

Author: mitaa

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: c0221c8897db309a79990367476177b1230bb264
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: 552bf75e7d689c42febc7798d31ae58d614418f9
+refs/heads/stable: 727f959095023d9fa749acbba49a4a904c57356b
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/CONTRIBUTING.md

@@ -6,7 +6,6 @@ links to the major sections:
 
 * [Feature Requests](#feature-requests)
 * [Bug Reports](#bug-reports)
-* [The Build System](#the-build-system)
 * [Pull Requests](#pull-requests)
 * [Writing Documentation](#writing-documentation)
 * [Issue Triage](#issue-triage)
@@ -78,66 +77,6 @@ to do this is to invoke `rustc` like this:
 $ RUST_BACKTRACE=1 rustc ...
 ```
 
-## The Build System
-
-Rust's build system allows you to bootstrap the compiler, run tests &
-benchmarks, generate documentation, install a fresh build of Rust, and more.
-It's your best friend when working on Rust, allowing you to compile & test
-your contributions before submission.
-
-All the configuration for the build system lives in [the `mk` directory][mkdir]
-in the project root. It can be hard to follow in places, as it uses some
-advanced Make features which make for some challenging reading. If you have
-questions on the build system internals, try asking in
-[`#rust-internals`][pound-rust-internals].
-
-[mkdir]: https://github.com/rust-lang/rust/tree/master/mk/
-
-### Configuration
-
-Before you can start building the compiler you need to configure the build for
-your system. In most cases, that will just mean using the defaults provided
-for Rust. Configuring involves invoking the `configure` script in the project
-root.
-
-```
-./configure
-```
-
-There are large number of options accepted by this script to alter the
-configuration used later in the build process. Some options to note:
-
-- `--enable-debug` - Build a debug version of the compiler (disables optimizations)
-- `--enable-optimize` - Enable optimizations (can be used with `--enable-debug`
-    to make a debug build with optimizations)
-- `--disable-valgrind-rpass` - Don't run tests with valgrind
-- `--enable-clang` - Prefer clang to gcc for building dependencies (e.g., LLVM)
-- `--enable-ccache` - Invoke clang/gcc with ccache to re-use object files between builds
-- `--enable-compiler-docs` - Build compiler documentation
-
-To see a full list of options, run `./configure --help`.
-
-### Useful Targets
-
-Some common make targets are:
-
-- `make rustc-stage1` - build up to (and including) the first stage. For most
-  cases we don't need to build the stage2 compiler, so we can save time by not
-  building it. The stage1 compiler is a fully functioning compiler and
-  (probably) will be enough to determine if your change works as expected.
-- `make check` - build the full compiler & run all tests (takes a while). This
-  is what gets run by the continuous integration system against your pull
-  request. You should run this before submitting to make sure your tests pass
-  & everything builds in the correct manner.
-- `make check-stage1-std NO_REBUILD=1` - test the standard library without
-  rebuilding the entire compiler
-- `make check TESTNAME=<path-to-test-file>.rs` - Run a single test file
-- `make check-stage1-rpass TESTNAME=<path-to-test-file>.rs` - Run a single
-  rpass test with the stage1 compiler (this will be quicker than running the
-  command above as we only build the stage1 compiler, not the entire thing).
-  You can also leave off the `-rpass` to run all stage1 test types.
-- `make check-stage1-coretest` - Run stage1 tests in `libcore`.
-
 ## Pull Requests
 
 Pull requests are the primary mechanism we use to change Rust. GitHub itself

branches/stable/mk/target.mk

@@ -17,6 +17,14 @@ export CFG_COMPILER_HOST_TRIPLE
 export CFG_DEFAULT_LINKER
 export CFG_DEFAULT_AR
 
+# The standard libraries should be held up to a higher standard than any old
+# code, make sure that these common warnings are denied by default. These can
+# be overridden during development temporarily. For stage0, we allow warnings
+# which may be bugs in stage0 (should be fixed in stage1+)
+RUST_LIB_FLAGS_ST0 += -W warnings
+RUST_LIB_FLAGS_ST1 += -D warnings
+RUST_LIB_FLAGS_ST2 += -D warnings
+
 # Macro that generates the full list of dependencies for a crate at a particular
 # stage/target/host tuple.
 #

branches/stable/src/doc/book/crates-and-modules.md

@@ -567,11 +567,10 @@ to it as "sayings". Similarly, the first `use` statement pulls in the
 `ja_greetings` as opposed to simply `greetings`. This can help to avoid
 ambiguity when importing similarly-named items from different places.
 
-The second `use` statement uses a star glob to bring in all public symbols from
-the `sayings::japanese::farewells` module. As you can see we can later refer to
+The second `use` statement uses a star glob to bring in _all_ symbols from the
+`sayings::japanese::farewells` module. As you can see we can later refer to
 the Japanese `goodbye` function with no module qualifiers. This kind of glob
-should be used sparingly. It’s worth noting that it only imports the public
-symbols, even if the code doing the globbing is in the same module.
+should be used sparingly.
 
 The third `use` statement bears more explanation. It's using "brace expansion"
 globbing to compress three `use` statements into one (this sort of syntax

branches/stable/src/doc/book/macros.md

@@ -478,9 +478,9 @@ which syntactic form it matches.
 
 There are additional rules regarding the next token after a metavariable:
 
-* `expr` and `stmt` variables may only be followed by one of: `=> , ;`
-* `ty` and `path` variables may only be followed by one of: `=> , = | ; : > [ { as where`
-* `pat` variables may only be followed by one of: `=> , = | if in`
+* `expr` variables may only be followed by one of: `=> , ;`
+* `ty` and `path` variables may only be followed by one of: `=> , : = > as`
+* `pat` variables may only be followed by one of: `=> , = if in`
 * Other variables may be followed by any token.
 
 These rules provide some flexibility for Rust’s syntax to evolve without

branches/stable/src/doc/book/syntax-index.md

@@ -2,7 +2,7 @@
 
 ## Keywords
 
-* `as`: primitive casting, or disambiguating the specific trait containing an item.  See [Casting Between Types (`as`)], [Universal Function Call Syntax (Angle-bracket Form)], [Associated Types].
+* `as`: primitive casting.  See [Casting Between Types (`as`)].
 * `break`: break out of loop.  See [Loops (Ending Iteration Early)].
 * `const`: constant items and constant raw pointers.  See [`const` and `static`], [Raw Pointers].
 * `continue`: continue to next loop iteration.  See [Loops (Ending Iteration Early)].
@@ -115,11 +115,8 @@
 * `::path`: path relative to the crate root (*i.e.* an explicitly absolute path).  See [Crates and Modules (Re-exporting with `pub use`)].
 * `self::path`: path relative to the current module (*i.e.* an explicitly relative path).  See [Crates and Modules (Re-exporting with `pub use`)].
 * `super::path`: path relative to the parent of the current module.  See [Crates and Modules (Re-exporting with `pub use`)].
-* `type::ident`, `<type as trait>::ident`: associated constants, functions, and types.  See [Associated Types].
+* `type::ident`: associated constants, functions, and types.  See [Associated Types].
 * `<type>::…`: associated item for a type which cannot be directly named (*e.g.* `<&T>::…`, `<[T]>::…`, *etc.*).  See [Associated Types].
-* `trait::method(…)`: disambiguating a method call by naming the trait which defines it. See [Universal Function Call Syntax].
-* `type::method(…)`: disambiguating a method call by naming the type for which it's defined. See [Universal Function Call Syntax].
-* `<type as trait>::method(…)`: disambiguating a method call by naming the trait _and_ type. See [Universal Function Call Syntax (Angle-bracket Form)].
 
 <!-- Generics -->
 
@@ -135,8 +132,7 @@
 <!-- Constraints -->
 
 * `T: U`: generic parameter `T` constrained to types that implement `U`.  See [Traits].
-* `T: 'a`: generic type `T` must outlive lifetime `'a`. When we say that a type 'outlives' the lifetime, we mean that it cannot transitively contain any references with lifetimes shorter than `'a`.
-* `T : 'static`: The generic type `T` contains no borrowed references other than `'static` ones.
+* `T: 'a`: generic type `T` must outlive lifetime `'a`.
 * `'b: 'a`: generic lifetime `'b` must outlive lifetime `'a`.
 * `T: ?Sized`: allow generic type parameter to be a dynamically-sized type.  See [Unsized Types (`?Sized`)].
 * `'a + trait`, `trait + trait`: compound type constraint.  See [Traits (Multiple Trait Bounds)].
@@ -238,8 +234,6 @@
 [Traits (`where` clause)]: traits.html#where-clause
 [Traits (Multiple Trait Bounds)]: traits.html#multiple-trait-bounds
 [Traits]: traits.html
-[Universal Function Call Syntax]: ufcs.html
-[Universal Function Call Syntax (Angle-bracket Form)]: ufcs.html#angle-bracket-form
 [Unsafe]: unsafe.html
 [Unsized Types (`?Sized`)]: unsized-types.html#sized
 [Variable Bindings]: variable-bindings.html

branches/stable/src/doc/reference.md

@@ -2095,7 +2095,7 @@ along with their default settings.  [Compiler
 plugins](book/compiler-plugins.html#lint-plugins) can provide additional lint checks.
 
 ```{.ignore}
-pub mod m1 {
+mod m1 {
     // Missing documentation is ignored here
     #[allow(missing_docs)]
     pub fn undocumented_one() -> i32 { 1 }
@@ -2115,9 +2115,9 @@ check on and off:
 
 ```{.ignore}
 #[warn(missing_docs)]
-pub mod m2{
+mod m2{
     #[allow(missing_docs)]
-    pub mod nested {
+    mod nested {
         // Missing documentation is ignored here
         pub fn undocumented_one() -> i32 { 1 }
 
@@ -2137,7 +2137,7 @@ that lint check:
 
 ```{.ignore}
 #[forbid(missing_docs)]
-pub mod m3 {
+mod m3 {
     // Attempting to toggle warning signals an error here
     #[allow(missing_docs)]
     /// Returns 2.

branches/stable/src/liballoc/boxed_test.rs

@@ -15,6 +15,7 @@ use core::ops::Deref;
 use core::result::Result::{Ok, Err};
 use core::clone::Clone;
 
+use std::boxed;
 use std::boxed::Box;
 
 #[test]

branches/stable/src/liballoc/lib.rs

@@ -70,33 +70,35 @@
        test(no_crate_inject, attr(allow(unused_variables), deny(warnings))))]
 #![no_std]
 #![needs_allocator]
-#![cfg_attr(not(stage0), deny(warnings))]
 
 #![feature(allocator)]
 #![feature(box_syntax)]
 #![feature(coerce_unsized)]
-#![feature(const_fn)]
 #![feature(core_intrinsics)]
 #![feature(custom_attribute)]
-#![feature(drop_in_place)]
-#![feature(dropck_parametricity)]
 #![feature(fundamental)]
 #![feature(lang_items)]
-#![feature(needs_allocator)]
 #![feature(optin_builtin_traits)]
 #![feature(placement_in_syntax)]
+#![feature(placement_new_protocol)]
+#![feature(raw)]
 #![feature(shared)]
 #![feature(staged_api)]
 #![feature(unboxed_closures)]
 #![feature(unique)]
 #![feature(unsafe_no_drop_flag, filling_drop)]
+#![feature(dropck_parametricity)]
 #![feature(unsize)]
+#![feature(drop_in_place)]
+#![feature(fn_traits)]
+#![feature(const_fn)]
+
+#![feature(needs_allocator)]
 
 // Issue# 30592: Systematically use alloc_system during stage0 since jemalloc
 // might be unavailable or disabled
 #![cfg_attr(stage0, feature(alloc_system))]
 
-#![cfg_attr(not(test), feature(raw, fn_traits, placement_new_protocol))]
 #![cfg_attr(test, feature(test, rustc_private, box_heap))]
 
 #[cfg(stage0)]

branches/stable/src/liballoc_jemalloc/lib.rs

@@ -16,7 +16,6 @@
             reason = "this library is unlikely to be stabilized in its current \
                       form or name",
             issue = "27783")]
-#![cfg_attr(not(stage0), deny(warnings))]
 #![feature(allocator)]
 #![feature(libc)]
 #![feature(staged_api)]

branches/stable/src/liballoc_system/lib.rs

@@ -12,7 +12,6 @@
 #![crate_type = "rlib"]
 #![no_std]
 #![allocator]
-#![cfg_attr(not(stage0), deny(warnings))]
 #![unstable(feature = "alloc_system",
             reason = "this library is unlikely to be stabilized in its current \
                       form or name",

branches/stable/src/libarena/lib.rs

@@ -27,7 +27,6 @@
        html_favicon_url = "https://doc.rust-lang.org/favicon.ico",
        html_root_url = "https://doc.rust-lang.org/nightly/",
        test(no_crate_inject, attr(deny(warnings))))]
-#![cfg_attr(not(stage0), deny(warnings))]
 
 #![feature(alloc)]
 #![feature(core_intrinsics)]

branches/stable/src/libcollections/btree/set.rs

@@ -12,7 +12,6 @@
 // to TreeMap
 
 use core::cmp::Ordering::{self, Less, Greater, Equal};
-use core::cmp::{min, max};
 use core::fmt::Debug;
 use core::fmt;
 use core::iter::{Peekable, FromIterator};
@@ -704,9 +703,7 @@ impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
     }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> ExactSizeIterator for Iter<'a, T> {
-    fn len(&self) -> usize { self.iter.len() }
-}
+impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
 
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -727,9 +724,7 @@ impl<T> DoubleEndedIterator for IntoIter<T> {
     }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ExactSizeIterator for IntoIter<T> {
-    fn len(&self) -> usize { self.iter.len() }
-}
+impl<T> ExactSizeIterator for IntoIter<T> {}
 
 
 impl<'a, T> Clone for Range<'a, T> {
@@ -785,12 +780,6 @@ impl<'a, T: Ord> Iterator for Difference<'a, T> {
             }
         }
     }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let a_len = self.a.len();
-        let b_len = self.b.len();
-        (a_len.saturating_sub(b_len), Some(a_len))
-    }
 }
 
 impl<'a, T> Clone for SymmetricDifference<'a, T> {
@@ -817,10 +806,6 @@ impl<'a, T: Ord> Iterator for SymmetricDifference<'a, T> {
             }
         }
     }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (0, Some(self.a.len() + self.b.len()))
-    }
 }
 
 impl<'a, T> Clone for Intersection<'a, T> {
@@ -857,10 +842,6 @@ impl<'a, T: Ord> Iterator for Intersection<'a, T> {
             }
         }
     }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (0, Some(min(self.a.len(), self.b.len())))
-    }
 }
 
 impl<'a, T> Clone for Union<'a, T> {
@@ -887,10 +868,4 @@ impl<'a, T: Ord> Iterator for Union<'a, T> {
             }
         }
     }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let a_len = self.a.len();
-        let b_len = self.b.len();
-        (max(a_len, b_len), Some(a_len + b_len))
-    }
 }

branches/stable/src/libcollections/lib.rs

@@ -28,7 +28,6 @@
 
 #![allow(trivial_casts)]
 #![cfg_attr(test, allow(deprecated))] // rand
-#![cfg_attr(not(stage0), deny(warnings))]
 
 #![feature(alloc)]
 #![feature(box_patterns)]
@@ -56,7 +55,7 @@
 #![feature(unicode)]
 #![feature(unique)]
 #![feature(unsafe_no_drop_flag)]
-#![cfg_attr(test, feature(rand, test))]
+#![cfg_attr(test, feature(clone_from_slice, rand, test))]
 
 #![no_std]