---

yaml
---
r: 273695
b: refs/heads/beta
c: 2bfc470
h: refs/heads/master
i:
  273693: 9999e9b
  273691: b37b092
  273687: 42d969c
  273679: 760ea36
  273663: 1e1e71c

Author: tedhorst

[refs]

@@ -23,7 +23,7 @@ refs/tags/0.9: 36870b185fc5f5486636d4515f0e22677493f225
 refs/tags/0.10: ac33f2b15782272ae348dbd7b14b8257b2148b5a
 refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
-refs/heads/beta: 3602f34e9cfe542210b6ac4302ae8d0f0799965b
+refs/heads/beta: 2bfc47075a9c2e7f0824bac0beb4d471a309312b
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/mk/crates.mk

@@ -57,7 +57,7 @@ TARGET_CRATES := libc std term \
 RUSTC_CRATES := rustc rustc_typeck rustc_mir rustc_borrowck rustc_resolve rustc_driver \
                 rustc_trans rustc_back rustc_llvm rustc_privacy rustc_lint \
                 rustc_data_structures rustc_front rustc_platform_intrinsics \
-                rustc_plugin rustc_metadata rustc_passes rustc_save_analysis
+                rustc_plugin rustc_metadata rustc_passes
 HOST_CRATES := syntax syntax_ext $(RUSTC_CRATES) rustdoc fmt_macros \
 		flate arena graphviz rbml log serialize
 TOOLS := compiletest rustdoc rustc rustbook error_index_generator
@@ -102,7 +102,7 @@ DEPS_rustc_data_structures := std log serialize
 DEPS_rustc_driver := arena flate getopts graphviz libc rustc rustc_back rustc_borrowck \
                      rustc_typeck rustc_mir rustc_resolve log syntax serialize rustc_llvm \
 	             rustc_trans rustc_privacy rustc_lint rustc_front rustc_plugin \
-                     rustc_metadata syntax_ext rustc_passes rustc_save_analysis
+                     rustc_metadata syntax_ext rustc_passes
 DEPS_rustc_front := std syntax log serialize
 DEPS_rustc_lint := rustc log syntax
 DEPS_rustc_llvm := native:rustllvm libc std rustc_bitflags
@@ -116,14 +116,13 @@ DEPS_rustc_privacy := rustc rustc_front log syntax
 DEPS_rustc_trans := arena flate getopts graphviz libc rustc rustc_back rustc_mir \
                     log syntax serialize rustc_llvm rustc_front rustc_platform_intrinsics \
 					rustc_const_eval
-DEPS_rustc_save_analysis := rustc log syntax rustc_front
 DEPS_rustc_typeck := rustc syntax rustc_front rustc_platform_intrinsics rustc_const_eval
 
 DEPS_rustdoc := rustc rustc_driver native:hoedown serialize getopts \
                 test rustc_lint rustc_front
 
 
-TOOL_DEPS_compiletest := test getopts log
+TOOL_DEPS_compiletest := test getopts
 TOOL_DEPS_rustdoc := rustdoc
 TOOL_DEPS_rustc := rustc_driver
 TOOL_DEPS_rustbook := std rustdoc

branches/beta/mk/main.mk

@@ -493,7 +493,7 @@ endif
 LD_LIBRARY_PATH_ENV_HOSTDIR$(1)_T_$(2)_H_$(3) := \
     $$(CURDIR)/$$(HLIB$(1)_H_$(3)):$$(CFG_LLVM_INST_DIR_$(3))/lib
 LD_LIBRARY_PATH_ENV_TARGETDIR$(1)_T_$(2)_H_$(3) := \
-    $$(CURDIR)/$$(TLIB$(1)_T_$(2)_H_$(CFG_BUILD))
+    $$(CURDIR)/$$(TLIB1_T_$(2)_H_$(CFG_BUILD))
 
 HOST_RPATH_VAR$(1)_T_$(2)_H_$(3) := \
   $$(LD_LIBRARY_PATH_ENV_NAME$(1)_T_$(2)_H_$(3))=$$(LD_LIBRARY_PATH_ENV_HOSTDIR$(1)_T_$(2)_H_$(3)):$$$$$$(LD_LIBRARY_PATH_ENV_NAME$(1)_T_$(2)_H_$(3))

branches/beta/src/bootstrap/build/native.rs

@@ -39,7 +39,12 @@ pub fn llvm(build: &Build, target: &str) {
 
     let _ = fs::remove_dir_all(&dst.join("build"));
     t!(fs::create_dir_all(&dst.join("build")));
-    let assertions = if build.config.llvm_assertions {"ON"} else {"OFF"};
+    let mut assertions = if build.config.llvm_assertions {"ON"} else {"OFF"};
+
+    // Disable LLVM assertions on ARM compilers until #32360 is fixed
+    if target.contains("arm") && target.contains("gnu") {
+        assertions = "OFF";
+    }
 
     // http://llvm.org/docs/CMake.html
     let mut cfg = cmake::Config::new(build.src.join("src/llvm"));

branches/beta/src/bootstrap/mk/Makefile.in

@@ -38,8 +38,8 @@ standalone-docs:
 	$(Q)$(BOOTSTRAP) --step doc-standalone
 check:
 	$(Q)$(BOOTSTRAP) --step check
-check-cargotest:
-	$(Q)$(BOOTSTRAP) --step check-cargotest
+cargotest:
+	$(Q)$(BOOTSTRAP) --step cargotest
 dist:
 	$(Q)$(BOOTSTRAP) --step dist
 

branches/beta/src/compiletest/runtest.rs

@@ -727,8 +727,11 @@ fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testpaths: &TestP
     script_str.push_str("type category enable Rust\n");
 
     // Set breakpoints on every line that contains the string "#break"
+    let source_file_name = testpaths.file.file_name().unwrap().to_string_lossy();
     for line in &breakpoint_lines {
-        script_str.push_str(&format!("breakpoint set --line {}\n", line));
+        script_str.push_str(&format!("breakpoint set --file '{}' --line {}\n",
+                                     source_file_name,
+                                     line));
     }
 
     // Append the other commands

branches/beta/src/doc/book/concurrency.md

@@ -94,54 +94,6 @@ fn main() {
 }
 ```
 
-As closures can capture variables from their environment, we can also try to
-bring some data into the other thread:
-
-```rust,ignore
-use std::thread;
-
-fn main() {
-    let x = 1;
-    thread::spawn(|| {
-        println!("x is {}", x);
-    });
-}
-```
-
-However, this gives us an error:
-
-```text
-5:19: 7:6 error: closure may outlive the current function, but it
-                 borrows `x`, which is owned by the current function
-...
-5:19: 7:6 help: to force the closure to take ownership of `x` (and any other referenced variables),
-          use the `move` keyword, as shown:
-      thread::spawn(move || {
-          println!("x is {}", x);
-      });
-```
-
-This is because by default closures capture variables by reference, and thus the
-closure only captures a _reference to `x`_. This is a problem, because the
-thread may outlive the scope of `x`, leading to a dangling pointer.
-
-To fix this, we use a `move` closure as mentioned in the error message. `move`
-closures are explained in depth [here](closures.html#move-closures); basically
-they move variables from their environment into themselves. This means that `x`
-is now owned by the closure, and cannot be used in `main()` after the call to
-`spawn()`.
-
-```rust
-use std::thread;
-
-fn main() {
-    let x = 1;
-    thread::spawn(move || {
-        println!("x is {}", x);
-    });
-}
-```
-
 Many languages have the ability to execute threads, but it's wildly unsafe.
 There are entire books about how to prevent errors that occur from shared
 mutable state. Rust helps out with its type system here as well, by preventing
@@ -193,64 +145,23 @@ This gives us an error:
 ```
 
 Rust knows this wouldn't be safe! If we had a reference to `data` in each
-thread, and the thread takes ownership of the reference, we'd have three owners!
-`data` gets moved out of `main` in the first call to `spawn()`, so subsequent
-calls in the loop cannot use this variable.
-
-So, we need some type that lets us have more than one owning reference to a
-value. Usually, we'd use `Rc<T>` for this, which is a reference counted type
-that provides shared ownership. It has some runtime bookkeeping that keeps track
-of the number of references to it, hence the "reference count" part of its name.
-
-Calling `clone()` on an `Rc<T>` will return a new owned reference and bump the
-internal reference count. We create one of these for each thread:
+thread, and the thread takes ownership of the reference, we'd have three
+owners!
 
+So, we need some type that lets us have more than one reference to a value and
+that we can share between threads, that is it must implement `Sync`.
 
-```ignore
-use std::thread;
-use std::time::Duration;
-use std::rc::Rc;
+We'll use `Arc<T>`, Rust's standard atomic reference count type, which
+wraps a value up with some extra runtime bookkeeping which allows us to
+share the ownership of the value between multiple references at the same time.
 
-fn main() {
-    let mut data = Rc::new(vec![1, 2, 3]);
-
-    for i in 0..3 {
-        // create a new owned reference
-        let data_ref = data.clone();
-
-        // use it in a thread
-        thread::spawn(move || {
-            data_ref[i] += 1;
-        });
-    }
-
-    thread::sleep(Duration::from_millis(50));
-}
-```
-
-This won't work, however, and will give us the error:
-
-```text
-13:9: 13:22 error: the trait `core::marker::Send` is not
-            implemented for the type `alloc::rc::Rc<collections::vec::Vec<i32>>`
-...
-13:9: 13:22 note: `alloc::rc::Rc<collections::vec::Vec<i32>>`
-            cannot be sent between threads safely
-```
-
-As the error message mentions, `Rc` cannot be sent between threads safely. This
-is because the internal reference count is not maintained in a thread safe
-matter and can have a data race.
-
-To solve this, we'll use `Arc<T>`, Rust's standard atomic reference count type.
+The bookkeeping consists of a count of how many of these references exist to
+the value, hence the reference count part of the name.
 
 The Atomic part means `Arc<T>` can safely be accessed from multiple threads.
 To do this the compiler guarantees that mutations of the internal count use
 indivisible operations which can't have data races.
 
-In essence, `Arc<T>` is a type that lets us share ownership of data _across
-threads_.
-
 
 ```ignore
 use std::thread;
@@ -271,7 +182,7 @@ fn main() {
 }
 ```
 
-Similarly to last time, we use `clone()` to create a new owned handle.
+We now call `clone()` on our `Arc<T>`, which increases the internal count.
 This handle is then moved into the new thread.
 
 And... still gives us an error.
@@ -282,21 +193,14 @@ And... still gives us an error.
                              ^~~~
 ```
 
-`Arc<T>` by default has immutable contents. It allows the _sharing_ of data
-between threads, but shared mutable data is unsafe and when threads are
-involved can cause data races!
-
+`Arc<T>` assumes one more property about its contents to ensure that it is safe
+to share across threads: it assumes its contents are `Sync`. This is true for
+our value if it's immutable, but we want to be able to mutate it, so we need
+something else to persuade the borrow checker we know what we're doing.
 
-Usually when we wish to make something in an immutable position mutable, we use
-`Cell<T>` or `RefCell<T>` which allow safe mutation via runtime checks or
-otherwise (see also: [Choosing Your Guarantees](choosing-your-guarantees.html)).
-However, similar to `Rc`, these are not thread safe. If we try using these, we
-will get an error about these types not being `Sync`, and the code will fail to
-compile.
-
-It looks like we need some type that allows us to safely mutate a shared value
-across threads, for example a type that can ensure only one thread at a time is
-able to mutate the value inside it at any one time.
+It looks like we need some type that allows us to safely mutate a shared value,
+for example a type that can ensure only one thread at a time is able to
+mutate the value inside it at any one time.
 
 For that, we can use the `Mutex<T>` type!
 
@@ -325,17 +229,7 @@ fn main() {
 Note that the value of `i` is bound (copied) to the closure and not shared
 among the threads.
 
-We're "locking" the mutex here. A mutex (short for "mutual exclusion"), as
-mentioned, only allows one thread at a time to access a value. When we wish to
-access the value, we use `lock()` on it. This will "lock" the mutex, and no
-other thread will be able to lock it (and hence, do anything with the value)
-until we're done with it. If a thread attempts to lock a mutex which is already
-locked, it will wait until the other thread releases the lock.
-
-The lock "release" here is implicit; when the result of the lock (in this case,
-`data`) goes out of scope, the lock is automatically released.
-
-Note that [`lock`](../std/sync/struct.Mutex.html#method.lock) method of
+Also note that [`lock`](../std/sync/struct.Mutex.html#method.lock) method of
 [`Mutex`](../std/sync/struct.Mutex.html) has this signature:
 
 ```ignore

branches/beta/src/doc/book/strings.md

@@ -44,11 +44,6 @@ let s = "foo\
 assert_eq!("foobar", s);
 ```
 
-Note that you normally cannot access a `str` directly, but only through a `&str`
-reference. This is because `str` is an unsized type which requires additional
-runtime information to be usable. For more information see the chapter on
-[unsized types][ut].
-
 Rust has more than only `&str`s though. A `String` is a heap-allocated string.
 This string is growable, and is also guaranteed to be UTF-8. `String`s are
 commonly created by converting from a string slice using the `to_string`
@@ -190,6 +185,5 @@ let hello_world = hello + &world;
 This is because `&String` can automatically coerce to a `&str`. This is a
 feature called ‘[`Deref` coercions][dc]’.
 
-[ut]: unsized-types.html
 [dc]: deref-coercions.html
 [connect]: ../std/net/struct.TcpStream.html#method.connect

branches/beta/src/doc/reference.md

@@ -3911,9 +3911,6 @@ The _heap_ is a general term that describes boxes.  The lifetime of an
 allocation in the heap depends on the lifetime of the box values pointing to
 it. Since box values may themselves be passed in and out of frames, or stored
 in the heap, heap allocations may outlive the frame they are allocated within.
-An allocation in the heap is guaranteed to reside at a single location in the
-heap for the whole lifetime of the allocation - it will never be relocated as
-a result of moving a box value.
 
 ### Memory ownership
 

branches/beta/src/etc/CONFIGS.md

@@ -10,3 +10,7 @@ These are some links to repos with configs which ease the use of rust.
 * [kate-config](https://github.com/rust-lang/kate-config)
 * [nano-config](https://github.com/rust-lang/nano-config)
 * [zsh-config](https://github.com/rust-lang/zsh-config)
+
+## Community-maintained Configs
+
+* [.editorconfig](https://gist.github.com/derhuerst/c9d1b9309e308d9851fa) ([what is this?](http://editorconfig.org/))

branches/beta/src/librustc/dep_graph/mod.rs

@@ -11,7 +11,7 @@
 use self::thread::{DepGraphThreadData, DepMessage};
 use middle::def_id::DefId;
 use syntax::ast::NodeId;
-use ty::TyCtxt;
+use middle::ty::TyCtxt;
 use rustc_front::hir;
 use rustc_front::intravisit::Visitor;
 use std::rc::Rc;

branches/beta/src/librustc/lib.rs

@@ -78,20 +78,17 @@ pub mod back {
     pub use rustc_back::svh;
 }
 
-pub mod cfg;
 pub mod dep_graph;
 
 pub mod front {
     pub mod check_attr;
     pub mod map;
 }
 
-pub mod infer;
-pub mod lint;
-
 pub mod middle {
     pub mod astconv_util;
     pub mod expr_use_visitor; // STAGE0: increase glitch immunity
+    pub mod cfg;
     pub mod check_match;
     pub mod const_eval;
     pub mod const_qualif;
@@ -105,6 +102,7 @@ pub mod middle {
     pub mod entry;
     pub mod free_region;
     pub mod intrinsicck;
+    pub mod infer;
     pub mod lang_items;
     pub mod liveness;
     pub mod mem_categorization;
@@ -115,6 +113,9 @@ pub mod middle {
     pub mod recursion_limit;
     pub mod resolve_lifetime;
     pub mod stability;
+    pub mod subst;
+    pub mod traits;
+    pub mod ty;
     pub mod weak_lang_items;
 }
 
@@ -127,8 +128,8 @@ pub mod mir {
 }
 
 pub mod session;
-pub mod traits;
-pub mod ty;
+
+pub mod lint;
 
 pub mod util {
     pub use rustc_back::sha2;

branches/beta/src/librustc/lint/context.rs

@@ -27,7 +27,7 @@ use self::TargetLint::*;
 
 use dep_graph::DepNode;
 use middle::privacy::AccessLevels;
-use ty::TyCtxt;
+use middle::ty::TyCtxt;
 use session::{config, early_error, Session};
 use lint::{Level, LevelSource, Lint, LintId, LintArray, LintPass};
 use lint::{EarlyLintPass, EarlyLintPassObject, LateLintPass, LateLintPassObject};

branches/beta/src/librustc/middle/astconv_util.rs

@@ -15,7 +15,7 @@
  */
 
 use middle::def::Def;
-use ty::{Ty, TyCtxt};
+use middle::ty::{Ty, TyCtxt};
 
 use syntax::codemap::Span;
 use rustc_front::hir as ast;