---

yaml
---
r: 216405
b: refs/heads/stable
c: f99658d
h: refs/heads/master
i:
  216403: 38c1080
v: v3

Author: jooert

[refs]

@@ -29,5 +29,5 @@ refs/heads/tmp: 378a370ff2057afeb1eae86eb6e78c476866a4a6
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: a5286998df566e736b32f6795bfc3803bdaf453d
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: 416e4127e9d220e5168a12308aa6c3274dc5e13a
+refs/heads/stable: f99658d7c7522a76b4fb7ff0d09b53183c136e79
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375

branches/stable/src/doc/not_found.md

@@ -57,12 +57,8 @@ function populate_rust_search() {
 
     // #18540, use a single token
 
-    var a = document.createElement("a");
-    a.href = "http://doc.rust-lang.org/core/?search=" + encodeURIComponent(lt);
-    a.textContent = lt;
     var search = document.getElementById('core-search');
-    search.innerHTML = "";
-    search.appendChild(a);
+    search.innerHTML = "<a href=\"http://doc.rust-lang.org/core/?search=" + lt + "\">" + lt + "</a>";
 }
 populate_site_search();
 populate_rust_search();

branches/stable/src/doc/reference.md

@@ -103,7 +103,7 @@ Non-doc comments are interpreted as a form of whitespace.
 
 ## Whitespace
 
-Whitespace is any non-empty string containing only the following characters:
+Whitespace is any non-empty string containing any the following characters:
 
 - `U+0020` (space, `' '`)
 - `U+0009` (tab, `'\t'`)
@@ -1897,8 +1897,8 @@ release builds.
 
 There are two kinds of configuration options, one that is either defined or not
 (`#[cfg(foo)]`), and the other that contains a string that can be checked
-against (`#[cfg(bar = "baz")]`). Currently, only compiler-defined configuration
-options can have the latter form.
+against (`#[cfg(bar = "baz")]` (currently only compiler-defined configuration
+options can have the latter form).
 
 ```
 // The function is only included in the build when compiling for OSX

branches/stable/src/doc/trpl/README.md

@@ -127,7 +127,7 @@ vector. When we try to compile this program, we get an error:
 
 ```text
 error: cannot borrow `x` as mutable because it is also borrowed as immutable
-    x.push("foo");
+    x.push(4);
     ^
 note: previous borrow of `x` occurs here; the immutable borrow prevents
 subsequent moves or mutable borrows of `x` until the borrow ends

branches/stable/src/doc/trpl/benchmark-tests.md

@@ -13,7 +13,7 @@ pub fn add_two(a: i32) -> i32 {
 }
 
 #[cfg(test)]
-mod test {
+mod tests {
     use super::*;
     use test::Bencher;
 

branches/stable/src/libcore/intrinsics.rs

@@ -139,21 +139,6 @@ extern "rust-intrinsic" {
     pub fn atomic_fence_rel();
     pub fn atomic_fence_acqrel();
 
-    /// A compiler-only memory barrier.
-    ///
-    /// Memory accesses will never be reordered across this barrier by the compiler,
-    /// but no instructions will be emitted for it. This is appropriate for operations
-    /// on the same thread that may be preempted, such as when interacting with signal
-    /// handlers.
-    #[cfg(not(stage0))]     // SNAP 857ef6e
-    pub fn atomic_singlethreadfence();
-    #[cfg(not(stage0))]     // SNAP 857ef6e
-    pub fn atomic_singlethreadfence_acq();
-    #[cfg(not(stage0))]     // SNAP 857ef6e
-    pub fn atomic_singlethreadfence_rel();
-    #[cfg(not(stage0))]     // SNAP 857ef6e
-    pub fn atomic_singlethreadfence_acqrel();
-
     /// Aborts the execution of the process.
     pub fn abort() -> !;
 
@@ -270,17 +255,12 @@ extern "rust-intrinsic" {
     /// Returns `true` if a type is managed (will be allocated on the local heap)
     pub fn owns_managed<T>() -> bool;
 
-    /// Calculates the offset from a pointer.
+    /// Calculates the offset from a pointer. The offset *must* be in-bounds of
+    /// the object, or one-byte-past-the-end. An arithmetic overflow is also
+    /// undefined behaviour.
     ///
     /// This is implemented as an intrinsic to avoid converting to and from an
     /// integer, since the conversion would throw away aliasing information.
-    ///
-    /// # Safety
-    ///
-    /// Both the starting and resulting pointer must be either in bounds or one
-    /// byte past the end of an allocated object. If either pointer is out of
-    /// bounds or arithmetic overflow occurs then any further use of the
-    /// returned value will result in undefined behavior.
     pub fn offset<T>(dst: *const T, offset: isize) -> *const T;
 
     /// Copies `count * size_of<T>` bytes from `src` to `dst`. The source
@@ -582,20 +562,3 @@ extern "rust-intrinsic" {
     /// cast to a `u64`; if `T` has no discriminant, returns 0.
     pub fn discriminant_value<T>(v: &T) -> u64;
 }
-
-#[cfg(not(stage0))]
-extern "rust-intrinsic" {
-    /// Performs an unchecked signed division, which results in undefined behavior,
-    /// in cases where y == 0, or x == int::MIN and y == -1
-    pub fn unchecked_sdiv<T>(x: T, y: T) -> T;
-    /// Performs an unchecked unsigned division, which results in undefined behavior,
-    /// in cases where y == 0
-    pub fn unchecked_udiv<T>(x: T, y: T) -> T;
-
-    /// Returns the remainder of an unchecked signed division, which results in
-    /// undefined behavior, in cases where y == 0, or x == int::MIN and y == -1
-    pub fn unchecked_urem<T>(x: T, y: T) -> T;
-    /// Returns the remainder of an unchecked signed division, which results in
-    /// undefined behavior, in cases where y == 0
-    pub fn unchecked_srem<T>(x: T, y: T) -> T;
-}

branches/stable/src/libcore/num/mod.rs

@@ -745,20 +745,7 @@ macro_rules! uint_impl {
         #[stable(feature = "rust1", since = "1.0.0")]
         #[inline]
         pub fn trailing_zeros(self) -> u32 {
-            // As of LLVM 3.6 the codegen for the zero-safe cttz8 intrinsic
-            // emits two conditional moves on x86_64. By promoting the value to
-            // u16 and setting bit 8, we get better code without any conditional
-            // operations.
-            // FIXME: There's a LLVM patch (http://reviews.llvm.org/D9284)
-            // pending, remove this workaround once LLVM generates better code
-            // for cttz8.
-            unsafe {
-                if $BITS == 8 {
-                    intrinsics::cttz16(self as u16 | 0x100) as u32
-                } else {
-                    $cttz(self as $ActualT) as u32
-                }
-            }
+            unsafe { $cttz(self as $ActualT) as u32 }
         }
 
         /// Shifts the bits to the left by a specified amount, `n`,

branches/stable/src/libcore/ptr.rs

@@ -284,10 +284,9 @@ impl<T: ?Sized> *const T {
     ///
     /// # Safety
     ///
-    /// Both the starting and resulting pointer must be either in bounds or one
-    /// byte past the end of an allocated object. If either pointer is out of
-    /// bounds or arithmetic overflow occurs then
-    /// any further use of the returned value will result in undefined behavior.
+    /// The offset must be in-bounds of the object, or one-byte-past-the-end.
+    /// Otherwise `offset` invokes Undefined Behaviour, regardless of whether
+    /// the pointer is used.
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub unsafe fn offset(self, count: isize) -> *const T where T: Sized {

branches/stable/src/libcoretest/option.rs

@@ -219,6 +219,7 @@ fn test_ord() {
     assert!(big > None);
 }
 
+/* FIXME(#20575)
 #[test]
 fn test_collect() {
     let v: Option<Vec<isize>> = (0..0).map(|_| Some(0)).collect();
@@ -240,26 +241,28 @@ fn test_collect() {
 
     assert!(v == None);
 }
-
+*/
 
 #[test]
 fn test_cloned() {
-    let val = 1u32;
-    let val_ref = &val;
+    let val1 = 1u32;
+    let mut val2 = 2u32;
+    let val1_ref = &val1;
     let opt_none: Option<&'static u32> = None;
-    let opt_ref = Some(&val);
-    let opt_ref_ref = Some(&val_ref);
+    let opt_ref = Some(&val1);
+    let opt_ref_ref = Some(&val1_ref);
+    let opt_mut_ref = Some(&mut val2);
 
     // None works
     assert_eq!(opt_none.clone(), None);
     assert_eq!(opt_none.cloned(), None);
 
     // Immutable ref works
-    assert_eq!(opt_ref.clone(), Some(&val));
+    assert_eq!(opt_ref.clone(), Some(&val1));
     assert_eq!(opt_ref.cloned(), Some(1u32));
 
     // Double Immutable ref works
-    assert_eq!(opt_ref_ref.clone(), Some(&val_ref));
-    assert_eq!(opt_ref_ref.clone().cloned(), Some(&val));
+    assert_eq!(opt_ref_ref.clone(), Some(&val1_ref));
+    assert_eq!(opt_ref_ref.clone().cloned(), Some(&val1));
     assert_eq!(opt_ref_ref.cloned().cloned(), Some(1u32));
 }

branches/stable/src/libcoretest/result.rs

@@ -8,11 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn op1() -> Result<isize, &'static str> { Ok(666) }
-fn op2() -> Result<isize, &'static str> { Err("sadface") }
+pub fn op1() -> Result<isize, &'static str> { Ok(666) }
+pub fn op2() -> Result<isize, &'static str> { Err("sadface") }
 
 #[test]
-fn test_and() {
+pub fn test_and() {
     assert_eq!(op1().and(Ok(667)).unwrap(), 667);
     assert_eq!(op1().and(Err::<i32, &'static str>("bad")).unwrap_err(),
                "bad");
@@ -23,7 +23,7 @@ fn test_and() {
 }
 
 #[test]
-fn test_and_then() {
+pub fn test_and_then() {
     assert_eq!(op1().and_then(|i| Ok::<isize, &'static str>(i + 1)).unwrap(), 667);
     assert_eq!(op1().and_then(|_| Err::<isize, &'static str>("bad")).unwrap_err(),
                "bad");
@@ -35,7 +35,7 @@ fn test_and_then() {
 }
 
 #[test]
-fn test_or() {
+pub fn test_or() {
     assert_eq!(op1().or(Ok::<_, &'static str>(667)).unwrap(), 666);
     assert_eq!(op1().or(Err("bad")).unwrap(), 666);
 
@@ -44,7 +44,7 @@ fn test_or() {
 }
 
 #[test]
-fn test_or_else() {
+pub fn test_or_else() {
     assert_eq!(op1().or_else(|_| Ok::<isize, &'static str>(667)).unwrap(), 666);
     assert_eq!(op1().or_else(|e| Err::<isize, &'static str>(e)).unwrap(), 666);
 
@@ -54,17 +54,18 @@ fn test_or_else() {
 }
 
 #[test]
-fn test_impl_map() {
+pub fn test_impl_map() {
     assert!(Ok::<isize, isize>(1).map(|x| x + 1) == Ok(2));
     assert!(Err::<isize, isize>(1).map(|x| x + 1) == Err(1));
 }
 
 #[test]
-fn test_impl_map_err() {
+pub fn test_impl_map_err() {
     assert!(Ok::<isize, isize>(1).map_err(|x| x + 1) == Ok(1));
     assert!(Err::<isize, isize>(1).map_err(|x| x + 1) == Err(2));
 }
 
+/* FIXME(#20575)
 #[test]
 fn test_collect() {
     let v: Result<Vec<isize>, ()> = (0..0).map(|_| Ok::<isize, ()>(0)).collect();
@@ -85,9 +86,10 @@ fn test_collect() {
     let v: Result<Vec<()>, isize> = functions.iter_mut().map(|f| (*f)()).collect();
     assert!(v == Err(1));
 }
+*/
 
 #[test]
-fn test_fmt_default() {
+pub fn test_fmt_default() {
     let ok: Result<isize, &'static str> = Ok(100);
     let err: Result<isize, &'static str> = Err("Err");
 
@@ -98,7 +100,7 @@ fn test_fmt_default() {
 }
 
 #[test]
-fn test_unwrap_or() {
+pub fn test_unwrap_or() {
     let ok: Result<isize, &'static str> = Ok(100);
     let ok_err: Result<isize, &'static str> = Err("Err");
 
@@ -107,7 +109,7 @@ fn test_unwrap_or() {
 }
 
 #[test]
-fn test_unwrap_or_else() {
+pub fn test_unwrap_or_else() {
     fn handler(msg: &'static str) -> isize {
         if msg == "I got this." {
             50

branches/stable/src/librustc/README.md

@@ -71,7 +71,7 @@ The rustc crate itself consists of the following submodules
 - util: ubiquitous types and helper functions
 - lib: bindings to LLVM
 
-The entry-point for the compiler is main() in the librustc_driver
+The entry-point for the compiler is main() in the librustc_trans
 crate.
 
 The 3 central data structures:

branches/stable/src/librustc/diagnostics.rs

@@ -168,25 +168,6 @@ match x {
 ```
 "##,
 
-E0013: r##"
-Static and const variables can refer to other const variables. But a const
-variable cannot refer to a static variable. For example, `Y` cannot refer to `X`
-here:
-
-```
-static X: i32 = 42;
-const Y: i32 = X;
-```
-
-To fix this, the value can be extracted as a const and then used:
-
-```
-const A: i32 = 42;
-static X: i32 = A;
-const Y: i32 = A;
-```
-"##,
-
 E0015: r##"
 The only function calls allowed in static or constant expressions are enum
 variant constructors or struct constructors (for unit or tuple structs). This
@@ -355,22 +336,6 @@ enum Method { GET, POST }
 ```
 "##,
 
-E0265: r##"
-This error indicates that a static or constant references itself.
-All statics and constants need to resolve to a value in an acyclic manner.
-
-For example, neither of the following can be sensibly compiled:
-
-```
-const X: u32 = X;
-```
-
-```
-const X: u32 = Y;
-const Y: u32 = X;
-```
-"##,
-
 E0267: r##"
 This error indicates the use of loop keyword (break or continue) inside a
 closure but outside of any loop. Break and continue can be used as normal
@@ -497,6 +462,7 @@ register_diagnostics! {
     E0010,
     E0011,
     E0012,
+    E0013,
     E0014,
     E0016,
     E0017,
@@ -516,6 +482,7 @@ register_diagnostics! {
     E0262, // illegal lifetime parameter name
     E0263, // lifetime name declared twice in same scope
     E0264, // unknown external lang item
+    E0265, // recursive constant
     E0266, // expected item
     E0269, // not all control paths return a value
     E0270, // computation may converge in a function marked as diverging

branches/stable/src/librustc/lib.rs

@@ -39,7 +39,6 @@
 #![feature(path_ext)]
 #![feature(str_char)]
 #![feature(into_cow)]
-#![feature(fs_canonicalize)]
 #![feature(slice_patterns)]
 #![cfg_attr(test, feature(test))]
 
@@ -139,6 +138,7 @@ pub mod plugin;
 pub mod lint;
 
 pub mod util {
+    pub use rustc_back::fs;
     pub use rustc_back::sha2;
 
     pub mod common;