---

yaml
---
r: 234751
b: refs/heads/tmp
c: a35f1b2
h: refs/heads/master
i:
  234749: ddee3bd
  234747: d7e8a0e
  234743: 13f0fd0
  234735: c9e5697
  234719: f97a746
  234687: f26a807
  234623: b5fc9f9
  234495: 8354446
v: v3

Author: Wallacoloo

[refs]

@@ -25,7 +25,7 @@ refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
 refs/heads/beta: d2e13e822a73e0ea46ae9e21afdd3155fc997f6d
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: fb690c7af6949cf55766a0075a16c381a1f1de12
+refs/heads/tmp: a35f1b29d743a7d5cc50469818f7b994ed186903
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: ab792abf1fcc28afbd315426213f6428da25c085
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828

branches/tmp/mk/dist.mk

@@ -77,7 +77,6 @@ $(PKG_TAR): $(PKG_FILES)
          -C $(S) \
          --exclude-vcs \
          --exclude=*~ \
-         --exclude=*.pyc \
          --exclude=*/llvm/test/*/*.ll \
          --exclude=*/llvm/test/*/*.td \
          --exclude=*/llvm/test/*/*.s \

branches/tmp/src/doc/trpl/choosing-your-guarantees.md

@@ -321,7 +321,7 @@ there's a lot of concurrent access happening.
 
 # Composition
 
-A common gripe when reading Rust code is with types like `Rc<RefCell<Vec<T>>>` (or even more more
+A common gripe when reading Rust code is with types like `Rc<RefCell<Vec<T>>>` (or even more
 complicated compositions of such types). It's not always clear what the composition does, or why the
 author chose one like this (and when one should be using such a composition in one's own code)
 

branches/tmp/src/doc/trpl/concurrency.md

@@ -26,8 +26,8 @@ to help us make sense of code that can possibly be concurrent.
 ### `Send`
 
 The first trait we're going to talk about is
-[`Send`](../std/marker/trait.Send.html). When a type `T` implements `Send`, it
-indicates that something of this type is able to have ownership transferred
+[`Send`](../std/marker/trait.Send.html). When a type `T` implements `Send`, it indicates
+to the compiler that something of this type is able to have ownership transferred
 safely between threads.
 
 This is important to enforce certain restrictions. For example, if we have a
@@ -42,19 +42,13 @@ us enforce that it can't leave the current thread.
 ### `Sync`
 
 The second of these traits is called [`Sync`](../std/marker/trait.Sync.html).
-When a type `T` implements `Sync`, it indicates that something
+When a type `T` implements `Sync`, it indicates to the compiler that something
 of this type has no possibility of introducing memory unsafety when used from
-multiple threads concurrently through shared references. This implies that
-types which don't have [interior mutability](mutability.html) are inherently
-`Sync`, which includes simple primitive types (like `u8`) and aggregate types
-containing them.
-
-For sharing references across threads, Rust provides a wrapper type called
-`Arc<T>`. `Arc<T>` implements `Send` and `Sync` if and only if `T` implements
-both `Send` and `Sync`. For example, an object of type `Arc<RefCell<U>>` cannot
-be transferred across threads because
-[`RefCell`](choosing-your-guarantees.html#refcell%3Ct%3E) does not implement
-`Sync`, consequently `Arc<RefCell<U>>` would not implement `Send`.
+multiple threads concurrently.
+
+For example, sharing immutable data with an atomic reference count is
+threadsafe. Rust provides a type like this, `Arc<T>`, and it implements `Sync`,
+so it is safe to share between threads.
 
 These two traits allow you to use the type system to make strong guarantees
 about the properties of your code under concurrency. Before we demonstrate
@@ -76,7 +70,7 @@ fn main() {
 }
 ```
 
-The `thread::spawn()` method accepts a [closure](closures.html), which is executed in a
+The `thread::spawn()` method accepts a closure, which is executed in a
 new thread. It returns a handle to the thread, that can be used to
 wait for the child thread to finish and extract its result:
 
@@ -221,18 +215,29 @@ fn main() {
 }
 ```
 
-Note that the value of `i` is bound (copied) to the closure and not shared
-among the threads.
 
-Also note that [`lock`](../std/sync/struct.Mutex.html#method.lock) method of
-[`Mutex`](../std/sync/struct.Mutex.html) has this signature:
+If we'd tried to use `Mutex<T>` without wrapping it in an `Arc<T>` we would have
+seen another error like:
+
+```text
+error: the trait `core::marker::Send` is not implemented for the type `std::sync::mutex::MutexGuard<'_, collections::vec::Vec<u32>>` [E0277]
+ thread::spawn(move || {
+                  ^~~~~~~~~~~~~
+note: `std::sync::mutex::MutexGuard<'_, collections::vec::Vec<u32>>` cannot be sent between threads safely
+ thread::spawn(move || {
+                  ^~~~~~~~~~~~~
+```
+
+You see, [`Mutex`](../std/sync/struct.Mutex.html) has a
+[`lock`](../std/sync/struct.Mutex.html#method.lock)
+method which has this signature:
 
 ```ignore
 fn lock(&self) -> LockResult<MutexGuard<T>>
 ```
 
-and because `Send` is not implemented for `MutexGuard<T>`, the guard cannot
-cross thread boundaries, ensuring thread-locality of lock acquire and release.
+and because `Send` is not implemented for `MutexGuard<T>`, we couldn't have
+transferred the guard across thread boundaries on it's own.
 
 Let's examine the body of the thread more closely:
 
@@ -312,24 +317,22 @@ use std::sync::mpsc;
 fn main() {
     let (tx, rx) = mpsc::channel();
 
-    for i in 0..10 {
+    for _ in 0..10 {
         let tx = tx.clone();
 
         thread::spawn(move || {
-            let answer = i * i;
+            let answer = 42;
 
             tx.send(answer);
         });
     }
 
-    for _ in 0..10 {
-        println!("{}", rx.recv().unwrap());
-    }
+   rx.recv().ok().expect("Could not receive answer");
 }
 ```
 
-Here we create 10 threads, asking each to calculate the square of a number (`i`
-at the time of `spawn()`), and then `send()` back the answer over the channel.
+A `u32` is `Send` because we can make a copy. So we create a thread, ask it to calculate
+the answer, and then it `send()`s us the answer over the channel.
 
 
 ## Panics

branches/tmp/src/librustc/diagnostics.rs

@@ -298,18 +298,10 @@ const FOO: i32 = { 0 }; // but brackets are useless here
 ```
 "##,
 
-// FIXME(#24111) Change the language here when const fn stabilizes
 E0015: r##"
 The only functions that can be called in static or constant expressions are
-`const` functions, and struct/enum constructors. `const` functions are only
-available on a nightly compiler. Rust currently does not support more general
-compile-time function execution.
-
-```
-const FOO: Option<u8> = Some(1); // enum constructor
-struct Bar {x: u8}
-const BAR: Bar = Bar {x: 1}; // struct constructor
-```
+`const` functions. Rust currently does not support more general compile-time
+function execution.
 
 See [RFC 911] for more details on the design of `const fn`s.
 

branches/tmp/src/librustc/lint/mod.rs

@@ -161,6 +161,9 @@ pub trait LateLintPass: LintPass {
     fn check_lifetime_ref(&mut self, _: &LateContext, _: &hir::Lifetime) { }
     fn check_lifetime_def(&mut self, _: &LateContext, _: &hir::LifetimeDef) { }
     fn check_explicit_self(&mut self, _: &LateContext, _: &hir::ExplicitSelf) { }
+    // Note that you shouldn't implement both check_mac and check_ast_mac,
+    // because then your lint will be called twice. Prefer check_ast_mac.
+    fn check_mac(&mut self, _: &LateContext, _: &ast::Mac) { }
     fn check_path(&mut self, _: &LateContext, _: &hir::Path, _: ast::NodeId) { }
     fn check_attribute(&mut self, _: &LateContext, _: &ast::Attribute) { }
 
@@ -206,6 +209,7 @@ pub trait EarlyLintPass: LintPass {
     fn check_lifetime_ref(&mut self, _: &EarlyContext, _: &ast::Lifetime) { }
     fn check_lifetime_def(&mut self, _: &EarlyContext, _: &ast::LifetimeDef) { }
     fn check_explicit_self(&mut self, _: &EarlyContext, _: &ast::ExplicitSelf) { }
+    fn check_mac(&mut self, _: &EarlyContext, _: &ast::Mac) { }
     fn check_path(&mut self, _: &EarlyContext, _: &ast::Path, _: ast::NodeId) { }
     fn check_attribute(&mut self, _: &EarlyContext, _: &ast::Attribute) { }
 

branches/tmp/src/librustc/middle/check_const.rs

@@ -39,7 +39,6 @@ use util::nodemap::NodeMap;
 use rustc_front::hir;
 use syntax::ast;
 use syntax::codemap::Span;
-use syntax::feature_gate::UnstableFeatures;
 use rustc_front::visit::{self, FnKind, Visitor};
 
 use std::collections::hash_map::Entry;
@@ -710,21 +709,10 @@ fn check_expr<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>,
             if !is_const {
                 v.add_qualif(ConstQualif::NOT_CONST);
                 if v.mode != Mode::Var {
-                    // FIXME(#24111) Remove this check when const fn stabilizes
-                    if let UnstableFeatures::Disallow = v.tcx.sess.opts.unstable_features {
-                        span_err!(v.tcx.sess, e.span, E0015,
-                                  "function calls in {}s are limited to \
-                                   struct and enum constructors", v.msg());
-                        v.tcx.sess.span_note(e.span,
-                                             "a limited form of compile-time function \
-                                              evaluation is available on a nightly \
-                                              compiler via `const fn`");
-                    } else {
-                        span_err!(v.tcx.sess, e.span, E0015,
-                                  "function calls in {}s are limited to \
-                                   constant functions, \
-                                   struct and enum constructors", v.msg());
-                    }
+                    span_err!(v.tcx.sess, e.span, E0015,
+                              "function calls in {}s are limited to \
+                               constant functions, \
+                               struct and enum constructors", v.msg());
                 }
             }
         }

branches/tmp/src/libsyntax/feature_gate.rs

@@ -197,12 +197,6 @@ const KNOWN_FEATURES: &'static [(&'static str, &'static str, Option<u32>, Status
 
     // allow overloading augmented assignment operations like `a += b`
     ("augmented_assignments", "1.5.0", None, Active),
-
-    // allow `#[no_debug]`
-    ("no_debug", "1.5.0", None, Active),
-
-    // allow `#[omit_gdb_pretty_printer_section]`
-    ("omit_gdb_pretty_printer_section", "1.5.0", None, Active),
 ];
 // (changing above list without updating src/doc/reference.md makes @cmr sad)
 
@@ -326,13 +320,8 @@ pub const KNOWN_ATTRIBUTES: &'static [(&'static str, AttributeType, AttributeGat
     ("link_section", Whitelisted, Ungated),
     ("no_builtins", Whitelisted, Ungated),
     ("no_mangle", Whitelisted, Ungated),
-    ("no_debug", Whitelisted, Gated("no_debug",
-                                    "the `#[no_debug]` attribute \
-                                     is an experimental feature")),
-    ("omit_gdb_pretty_printer_section", Whitelisted, Gated("omit_gdb_pretty_printer_section",
-                                                       "the `#[omit_gdb_pretty_printer_section]` \
-                                                        attribute is just used for the Rust test \
-                                                        suite")),
+    ("no_debug", Whitelisted, Ungated),
+    ("omit_gdb_pretty_printer_section", Whitelisted, Ungated),
     ("unsafe_no_drop_flag", Whitelisted, Gated("unsafe_no_drop_flag",
                                                "unsafe_no_drop_flag has unstable semantics \
                                                 and may be removed in the future")),

branches/tmp/src/test/auxiliary/cross_crate_spans.rs

@@ -11,7 +11,6 @@
 #![crate_type = "rlib"]
 
 #![allow(unused_variables)]
-#![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
 // no-prefer-dynamic

branches/tmp/src/test/compile-fail/borrowck-loan-of-static-data-issue-27616.rs renamed to branches/tmp/src/test/borrowck-loan-of-static-data-issue-27616.rs

@@ -23,7 +23,7 @@ fn evil(mut s: &'static mut String)
     let alias: &'static mut String = s;
     let inner: &str = &alias;
     // free value
-    *s = String::new(); //~ ERROR use of moved value
+    *s = String::new(); //~ ERROR cannot assign
     let _spray = "0wned".to_owned();
     // ... and then use it
     println!("{}", inner);

branches/tmp/src/test/compile-fail/feature-gate-no-debug.rs

@@ -80,7 +80,6 @@
 
 #![allow(unused_variables)]
 #![allow(dead_code)]
-#![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
 trait TraitWithAssocType {

branches/tmp/src/test/compile-fail/feature-gate-omit-gdb-pretty-printer-section.rs

@@ -44,7 +44,6 @@
 
 #![allow(unused_variables)]
 #![allow(dead_code)]
-#![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
 // N.B. These are `mut` only so they don't constant fold away.

branches/tmp/src/test/debuginfo/associated-types.rs

@@ -49,7 +49,6 @@
 // gdb-command:continue
 
 #![allow(unused_variables)]
-#![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
 // N.B. These are `mut` only so they don't constant fold away.

branches/tmp/src/test/debuginfo/basic-types-globals-metadata.rs

@@ -64,7 +64,6 @@
 // gdb-command:continue
 
 #![allow(unused_variables)]
-#![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
 fn main() {

branches/tmp/src/test/debuginfo/basic-types-globals.rs

@@ -82,7 +82,6 @@
 // gdb-check:$28 = 9.25
 
 #![allow(unused_variables)]
-#![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
 static mut B: bool = false;

branches/tmp/src/test/debuginfo/basic-types-metadata.rs

@@ -87,7 +87,6 @@
 // lldb-check:[...]$12 = 3.5
 
 #![allow(unused_variables)]
-#![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
 fn main() {

branches/tmp/src/test/debuginfo/basic-types-mut-globals.rs

@@ -108,7 +108,6 @@
 // lldb-check:[...]$12 = 3.5
 
 #![allow(unused_variables)]
-#![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
 fn main() {

branches/tmp/src/test/debuginfo/basic-types.rs

@@ -40,7 +40,6 @@
 // lldb-check:[...]$2 = TheC
 
 #![allow(unused_variables)]
-#![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
 enum ABC { TheA, TheB, TheC }

branches/tmp/src/test/debuginfo/borrowed-basic.rs

@@ -39,7 +39,6 @@
 // lldb-check:[...]$2 = TheOnlyCase(4820353753753434)
 
 #![allow(unused_variables)]
-#![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
 // The first element is to ensure proper alignment, irrespective of the machines word size. Since

branches/tmp/src/test/debuginfo/borrowed-c-style-enum.rs

@@ -64,7 +64,6 @@
 
 #![allow(unused_variables)]
 #![feature(box_syntax)]
-#![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
 struct SomeStruct {

branches/tmp/src/test/debuginfo/borrowed-enum.rs

@@ -42,7 +42,6 @@
 
 #![allow(unused_variables)]
 #![feature(box_syntax)]
-#![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
 fn main() {

branches/tmp/src/test/debuginfo/borrowed-struct.rs

@@ -112,7 +112,6 @@
 
 #![allow(unused_variables)]
 #![feature(box_syntax)]
-#![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
 fn main() {

branches/tmp/src/test/debuginfo/borrowed-tuple.rs

@@ -32,7 +32,6 @@
 
 #![allow(unused_variables)]
 #![feature(box_syntax)]
-#![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
 fn main() {

branches/tmp/src/test/debuginfo/borrowed-unique-basic.rs

@@ -35,7 +35,6 @@
 
 #![allow(unused_variables)]
 #![feature(box_syntax)]
-#![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
 struct StructWithSomePadding {