---

yaml
---
r: 219623
b: refs/heads/snap-stage3
c: 8e3ea5d
h: refs/heads/master
i:
  219621: 0436221
  219619: 0e85084
  219615: 5009d02
v: v3

Author: CruzBishop

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: c044791d80ea0dc5c4b57b6030a67b69f8510239
-refs/heads/snap-stage3: b36ae019468c36c995523d797446a372ab9d14e1
+refs/heads/snap-stage3: 8e3ea5d5014de1a590a79d05d0a64a0f618c3afa
 refs/heads/try: b53c0f93eedcdedd4fd89bccc5a3a09d1c5cd23e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/snap-stage3/.gitignore

@@ -19,6 +19,7 @@
 *.exe
 *.fn
 *.html
+*.kdev4
 *.ky
 *.ll
 *.llvm

branches/snap-stage3/RELEASES.md

@@ -1,18 +1,3 @@
-Version 1.2.0 (August 2015)
-===========================
-
-Highlights
-----------
-
-* [Parallel codegen][parcodegen] is now working again, which can substantially
-  speed up large builds in debug mode; It also gets another ~33% speedup when
-  bootstrapping on a 4 core machine (using 8 jobs). It's not enabled by default,
-  but will be "in the near future"
-
-
-[parcodegen]: https://github.com/rust-lang/rust/pull/26018
-
-
 Version 1.1.0 (June 2015)
 =========================
 
@@ -21,28 +6,29 @@ Version 1.1.0 (June 2015)
 Highlights
 ----------
 
-* The [`std::fs` module has been expanded][fs] to expand the set of
+* The [`std::fs` module has been expanded][fs-expand] to expand the set of
   functionality exposed:
   * `DirEntry` now supports optimizations like `file_type` and `metadata` which
     don't incur a syscall on some platforms.
   * A `symlink_metadata` function has been added.
   * The `fs::Metadata` structure now lowers to its OS counterpart, providing
     access to all underlying information.
-* The compiler now contains extended explanations of many errors. When an error
-  with an explanation occurs the compiler suggests using the `--explain` flag
-  to read the explanation. Error explanations are also [available online][err-index].
+* The compiler contains extended explanations of many errors.  When it
+  emits such an error it also suggests using the `--explain` flag to
+  read the extended explanations, which are also [cataloged on the web
+  site][err].
 * Thanks to multiple [improvements][sk] to [type checking][pre], as
   well as other work, the time to bootstrap the compiler decreased by
   32%.
 
 Libraries
 ---------
 
-* The [`str::split_whitespace`] method splits a string on unicode
+* The `str::split_whitespace` method splits a string on unicode
   whitespace boundaries.
 * On both Windows and Unix, new extension traits provide conversion of
   I/O types to and from the underlying system handles. On Unix, these
-  traits are [`FromRawFd`] and [`AsRawFd`], on Windows `FromRawHandle`
+  traits are [`FrowRawFd`] and [`AsRawFd`], on Windows `FromRawHandle`
   and `AsRawHandle`. These are implemented for `File`, `TcpStream`,
   `TcpListener`, and `UpdSocket`. Further implementations for
   `std::process` will be stabilized later.
@@ -94,14 +80,15 @@ Misc
 * [The `drop_with_repr_extern` lint warns about mixing `repr(C)`
   with `Drop`][drop].
 
-[`str::split_whitespace`]: http://doc.rust-lang.org/nightly/std/primitive.str.html#method.split_whitespace
+[`split_whitespace`]: http://doc.rust-lang.org/nightly/std/primitive.str.html#method.split_whitespace
+[`Iterator::cloned`]: http://doc.rust-lang.org/nightly/core/iter/trait.Iterator.html#method.cloned
 [`FromRawFd`]: http://doc.rust-lang.org/nightly/std/os/unix/io/trait.FromRawFd.html
 [`AsRawFd`]: http://doc.rust-lang.org/nightly/std/os/unix/io/trait.AsRawFd.html
 [`std::os::unix::symlink`]: http://doc.rust-lang.org/nightly/std/os/unix/fs/fn.symlink.html
 [`IntoIterator`]: http://doc.rust-lang.org/nightly/std/iter/trait.IntoIterator.html
 [`From`]: http://doc.rust-lang.org/nightly/std/convert/trait.From.html
 [rf]: https://github.com/rust-lang/rust/pull/24491
-[err-index]: http://doc.rust-lang.org/error-index.html
+[err]: http://doc.rust-lang.org/error-index.html
 [sk]: https://github.com/rust-lang/rust/pull/24615
 [pre]: https://github.com/rust-lang/rust/pull/25323
 [file]: https://github.com/rust-lang/rust/pull/24598
@@ -264,6 +251,7 @@ Misc
 [sw]: https://github.com/rust-lang/rfcs/blob/master/text/1054-str-words.md
 [th]: https://github.com/rust-lang/rfcs/blob/master/text/0909-move-thread-local-to-std-thread.md
 [send-rfc]: https://github.com/rust-lang/rfcs/blob/master/text/0458-send-improvements.md
+[scoped]: http://static.rust-lang.org/doc/master/std/thread/fn.scoped.html
 [moar-ufcs]: https://github.com/rust-lang/rust/pull/22172
 [prim-inherent]: https://github.com/rust-lang/rust/pull/23104
 [overflow]: https://github.com/rust-lang/rfcs/blob/master/text/0560-integer-overflow.md
@@ -273,10 +261,12 @@ Misc
 [string-pattern]: https://github.com/rust-lang/rust/pull/22466
 [oibit-final]: https://github.com/rust-lang/rust/pull/21689
 [reflect]: https://github.com/rust-lang/rust/pull/23712
+[debug-builder]: https://github.com/rust-lang/rfcs/blob/master/text/0640-debug-improvements.md
 [conversion]: https://github.com/rust-lang/rfcs/pull/529
 [num-traits]: https://github.com/rust-lang/rust/pull/23549
 [index-value]: https://github.com/rust-lang/rust/pull/23601
 [dropck]: https://github.com/rust-lang/rfcs/pull/769
+[fundamental]: https://github.com/rust-lang/rfcs/pull/1023
 [ci-compare]: https://gist.github.com/brson/a30a77836fbec057cbee
 [fn-inherit]: https://github.com/rust-lang/rust/pull/23282
 [fn-blanket]: https://github.com/rust-lang/rust/pull/23895
@@ -379,6 +369,7 @@ Version 1.0.0-alpha.2 (February 2015)
 [osstr]: https://github.com/rust-lang/rust/pull/21488
 [osstr-rfc]: https://github.com/rust-lang/rfcs/blob/master/text/0517-io-os-reform.md
 [Self]: https://github.com/rust-lang/rust/pull/22158
+[ufcs]: https://github.com/rust-lang/rust/pull/21077
 [ufcs-rfc]: https://github.com/rust-lang/rfcs/blob/master/text/0132-ufcs.md
 [un]: https://github.com/rust-lang/rust/pull/22256
 

branches/snap-stage3/mk/cfg/x86_64-pc-windows-msvc.mk

@@ -23,6 +23,64 @@ CFG_RUN_x86_64-pc-windows-msvc=$(2)
 CFG_RUN_TARG_x86_64-pc-windows-msvc=$(call CFG_RUN_x86_64-pc-windows-msvc,,$(2))
 CFG_GNU_TRIPLE_x86_64-pc-windows-msvc := x86_64-pc-win32
 
+# These two environment variables are scraped by the `./configure` script and
+# are necessary for `cl.exe` to find standard headers (the INCLUDE variable) and
+# for `link.exe` to find standard libraries (the LIB variable).
+ifdef CFG_MSVC_INCLUDE_PATH
+export INCLUDE := $(CFG_MSVC_INCLUDE_PATH)
+endif
+ifdef CFG_MSVC_LIB_PATH
+export LIB := $(CFG_MSVC_LIB_PATH)
+endif
+
+# Unfortunately `link.exe` is also a program in `/usr/bin` on MinGW installs,
+# but it's not the one that we want. As a result we make sure that our detected
+# `link.exe` shows up in PATH first.
+ifdef CFG_MSVC_LINK
+export PATH := $(CFG_MSVC_ROOT)/VC/bin/amd64:$(PATH)
+endif
+
+# There are more comments about this available in the target specification for
+# Windows MSVC in the compiler, but the gist of it is that we use `llvm-ar.exe`
+# instead of `lib.exe` for assembling archives, so we need to inject this custom
+# dependency here.
+NATIVE_TOOL_DEPS_core_T_x86_64-pc-windows-msvc += llvm-ar.exe
+INSTALLED_BINS_x86_64-pc-windows-msvc += llvm-ar.exe
+
+# When working with MSVC on windows, each DLL needs to explicitly declare its
+# interface to the outside world through some means. The options for doing so
+# include:
+#
+# 1. A custom attribute on each function itself
+# 2. A linker argument saying what to export
+# 3. A file which lists all symbols that need to be exported
+#
+# The Rust compiler takes care (1) for us for all Rust code by annotating all
+# public-facing functions with dllexport, but we have a few native dependencies
+# which need to cross the DLL boundary. The most important of these dependencies
+# is LLVM which is linked into `rustc_llvm.dll` but primarily used from
+# `rustc_trans.dll`. This means that many of LLVM's C API functions need to be
+# exposed from `rustc_llvm.dll` to be forwarded over the boundary.
+#
+# Unfortunately, at this time, LLVM does not handle this sort of exportation on
+# Windows for us, so we're forced to do it ourselves if we want it (which seems
+# like the path of least resistance right now). To do this we generate a `.DEF`
+# file [1] which we then custom-pass to the linker when building the rustc_llvm
+# crate. This DEF file list all symbols that are exported from
+# `src/librustc_llvm/lib.rs` and is generated by a small python script.
+#
+# Fun times!
+#
+# [1]: https://msdn.microsoft.com/en-us/library/28d6s79h.aspx
+RUSTFLAGS_rustc_llvm_T_x86_64-pc-windows-msvc += \
+	-C link-args="-DEF:x86_64-pc-windows-msvc/rt/rustc_llvm.def"
+CUSTOM_DEPS_rustc_llvm_T_x86_64-pc-windows-msvc += \
+	x86_64-pc-windows-msvc/rt/rustc_llvm.def
+
+x86_64-pc-windows-msvc/rt/rustc_llvm.def: $(S)src/etc/mklldef.py \
+			$(S)src/librustc_llvm/lib.rs
+	$(CFG_PYTHON) $^ $@ rustc_llvm-$(CFG_FILENAME_EXTRA)
+
 # All windows nightiles are currently a GNU triple, so this MSVC triple is not
 # bootstrapping from itself. This is relevant during stage0, and other parts of
 # the build system take this into account.

branches/snap-stage3/mk/platform.mk

@@ -238,72 +238,3 @@ endef
 
 $(foreach target,$(CFG_TARGET), \
   $(eval $(call CFG_MAKE_TOOLCHAIN,$(target))))
-
-# These two environment variables are scraped by the `./configure` script and
-# are necessary for `cl.exe` to find standard headers (the INCLUDE variable) and
-# for `link.exe` to find standard libraries (the LIB variable).
-ifdef CFG_MSVC_INCLUDE_PATH
-export INCLUDE := $(CFG_MSVC_INCLUDE_PATH)
-endif
-ifdef CFG_MSVC_LIB_PATH
-export LIB := $(CFG_MSVC_LIB_PATH)
-endif
-
-# Unfortunately `link.exe` is also a program in `/usr/bin` on MinGW installs,
-# but it's not the one that we want. As a result we make sure that our detected
-# `link.exe` shows up in PATH first.
-ifdef CFG_MSVC_LINK
-export PATH := $(CFG_MSVC_ROOT)/VC/bin/amd64:$(PATH)
-endif
-
-# There are more comments about this available in the target specification for
-# Windows MSVC in the compiler, but the gist of it is that we use `llvm-ar.exe`
-# instead of `lib.exe` for assembling archives, so we need to inject this custom
-# dependency here.
-define ADD_LLVM_AR_TO_MSVC_DEPS
-ifeq ($$(findstring msvc,$(1)),msvc)
-NATIVE_TOOL_DEPS_core_T_$(1) += llvm-ar.exe
-INSTALLED_BINS_$(1) += llvm-ar.exe
-endif
-endef
-
-$(foreach target,$(CFG_TARGET), \
-  $(eval $(call ADD_LLVM_AR_TO_MSVC_DEPS,$(target))))
-
-# When working with MSVC on windows, each DLL needs to explicitly declare its
-# interface to the outside world through some means. The options for doing so
-# include:
-#
-# 1. A custom attribute on each function itself
-# 2. A linker argument saying what to export
-# 3. A file which lists all symbols that need to be exported
-#
-# The Rust compiler takes care (1) for us for all Rust code by annotating all
-# public-facing functions with dllexport, but we have a few native dependencies
-# which need to cross the DLL boundary. The most important of these dependencies
-# is LLVM which is linked into `rustc_llvm.dll` but primarily used from
-# `rustc_trans.dll`. This means that many of LLVM's C API functions need to be
-# exposed from `rustc_llvm.dll` to be forwarded over the boundary.
-#
-# Unfortunately, at this time, LLVM does not handle this sort of exportation on
-# Windows for us, so we're forced to do it ourselves if we want it (which seems
-# like the path of least resistance right now). To do this we generate a `.DEF`
-# file [1] which we then custom-pass to the linker when building the rustc_llvm
-# crate. This DEF file list all symbols that are exported from
-# `src/librustc_llvm/lib.rs` and is generated by a small python script.
-#
-# Fun times!
-#
-# [1]: https://msdn.microsoft.com/en-us/library/28d6s79h.aspx
-define ADD_RUSTC_LLVM_DEF_TO_MSVC
-ifeq ($$(findstring msvc,$(1)),msvc)
-RUSTFLAGS_rustc_llvm_T_$(1) += -C link-args="-DEF:$(1)/rt/rustc_llvm.def"
-CUSTOM_DEPS_rustc_llvm_T_$(1) += $(1)/rt/rustc_llvm.def
-
-$(1)/rt/rustc_llvm.def: $$(S)src/etc/mklldef.py $$(S)src/librustc_llvm/lib.rs
-	$$(CFG_PYTHON) $$^ $$@ rustc_llvm-$$(CFG_FILENAME_EXTRA)
-endif
-endef
-
-$(foreach target,$(CFG_TARGET), \
-  $(eval $(call ADD_RUSTC_LLVM_DEF_TO_MSVC,$(target))))

branches/snap-stage3/mk/rt.mk

@@ -53,12 +53,9 @@ NATIVE_DEPS_hoedown_$(1) := hoedown/src/autolink.c \
 NATIVE_DEPS_miniz_$(1) = miniz.c
 NATIVE_DEPS_rust_builtin_$(1) := rust_builtin.c \
 			rust_android_dummy.c
-NATIVE_DEPS_rustrt_native_$(1) := arch/$$(HOST_$(1))/record_sp.S
-ifeq ($$(findstring msvc,$(1)),msvc)
-NATIVE_DEPS_rustrt_native_$(1) += rust_try_msvc_64.ll
-else
-NATIVE_DEPS_rustrt_native_$(1) += rust_try.ll
-endif
+NATIVE_DEPS_rustrt_native_$(1) := \
+			rust_try.ll \
+			arch/$$(HOST_$(1))/record_sp.S
 NATIVE_DEPS_rust_test_helpers_$(1) := rust_test_helpers.c
 NATIVE_DEPS_morestack_$(1) := arch/$$(HOST_$(1))/morestack.S
 

branches/snap-stage3/src/doc/trpl/ffi.md

@@ -309,8 +309,8 @@ and invokes callbacks from there.
 In these cases access to Rust data structures inside the callbacks is
 especially unsafe and proper synchronization mechanisms must be used.
 Besides classical synchronization mechanisms like mutexes, one possibility in
-Rust is to use channels (in `std::sync::mpsc`) to forward data from the C
-thread that invoked the callback into a Rust thread.
+Rust is to use channels (in `std::comm`) to forward data from the C thread
+that invoked the callback into a Rust thread.
 
 If an asynchronous callback targets a special object in the Rust address space
 it is also absolutely necessary that no more callbacks are performed by the

branches/snap-stage3/src/liballoc/arc.rs

@@ -77,7 +77,7 @@ use core::atomic;
 use core::atomic::Ordering::{Relaxed, Release, Acquire, SeqCst};
 use core::fmt;
 use core::cmp::Ordering;
-use core::mem::{align_of_val, size_of_val};
+use core::mem::{min_align_of_val, size_of_val};
 use core::intrinsics::drop_in_place;
 use core::mem;
 use core::nonzero::NonZero;
@@ -241,7 +241,7 @@ impl<T: ?Sized> Arc<T> {
 
         if self.inner().weak.fetch_sub(1, Release) == 1 {
             atomic::fence(Acquire);
-            deallocate(ptr as *mut u8, size_of_val(&*ptr), align_of_val(&*ptr))
+            deallocate(ptr as *mut u8, size_of_val(&*ptr), min_align_of_val(&*ptr))
         }
     }
 }
@@ -565,7 +565,7 @@ impl<T: ?Sized> Drop for Weak<T> {
             atomic::fence(Acquire);
             unsafe { deallocate(ptr as *mut u8,
                                 size_of_val(&*ptr),
-                                align_of_val(&*ptr)) }
+                                min_align_of_val(&*ptr)) }
         }
     }
 }

branches/snap-stage3/src/liballoc/boxed.rs

@@ -116,7 +116,7 @@ impl<T : ?Sized> Box<T> {
     /// of `T` and releases memory. Since the way `Box` allocates and
     /// releases memory is unspecified, the only valid pointer to pass
     /// to this function is the one taken from another `Box` with
-    /// `Box::into_raw` function.
+    /// `boxed::into_raw` function.
     ///
     /// Function is unsafe, because improper use of this function may
     /// lead to memory problems like double-free, for example if the
@@ -140,8 +140,10 @@ impl<T : ?Sized> Box<T> {
     /// # Examples
     /// ```
     /// # #![feature(box_raw)]
+    /// use std::boxed;
+    ///
     /// let seventeen = Box::new(17u32);
-    /// let raw = Box::into_raw(seventeen);
+    /// let raw = boxed::into_raw(seventeen);
     /// let boxed_again = unsafe { Box::from_raw(raw) };
     /// ```
     #[unstable(feature = "box_raw", reason = "may be renamed")]

branches/snap-stage3/src/liballoc/boxed_test.rs

@@ -76,9 +76,9 @@ fn deref() {
 
 #[test]
 fn raw_sized() {
-    let x = Box::new(17);
-    let p = Box::into_raw(x);
     unsafe {
+        let x = Box::new(17);
+        let p = boxed::into_raw(x);
         assert_eq!(17, *p);
         *p = 19;
         let y = Box::from_raw(p);
@@ -105,9 +105,9 @@ fn raw_trait() {
         }
     }
 
-    let x: Box<Foo> = Box::new(Bar(17));
-    let p = Box::into_raw(x);
     unsafe {
+        let x: Box<Foo> = Box::new(Bar(17));
+        let p = boxed::into_raw(x);
         assert_eq!(17, (*p).get());
         (*p).set(19);
         let y: Box<Foo> = Box::from_raw(p);

branches/snap-stage3/src/liballoc/rc.rs

@@ -162,7 +162,7 @@ use core::fmt;
 use core::hash::{Hasher, Hash};
 use core::intrinsics::{assume, drop_in_place};
 use core::marker::{self, Unsize};
-use core::mem::{self, align_of, size_of, align_of_val, size_of_val, forget};
+use core::mem::{self, min_align_of, size_of, min_align_of_val, size_of_val, forget};
 use core::nonzero::NonZero;
 use core::ops::{CoerceUnsized, Deref};
 use core::ptr;
@@ -246,7 +246,7 @@ impl<T> Rc<T> {
                 // destruct the box and skip our Drop
                 // we can ignore the refcounts because we know we're unique
                 deallocate(*rc._ptr as *mut u8, size_of::<RcBox<T>>(),
-                            align_of::<RcBox<T>>());
+                            min_align_of::<RcBox<T>>());
                 forget(rc);
                 Ok(val)
             }
@@ -496,7 +496,7 @@ impl<T: ?Sized> Drop for Rc<T> {
                     if self.weak() == 0 {
                         deallocate(ptr as *mut u8,
                                    size_of_val(&*ptr),
-                                   align_of_val(&*ptr))
+                                   min_align_of_val(&*ptr))
                     }
                 }
             }
@@ -805,7 +805,7 @@ impl<T: ?Sized> Drop for Weak<T> {
                 // the strong pointers have disappeared.
                 if self.weak() == 0 {
                     deallocate(ptr as *mut u8, size_of_val(&*ptr),
-                               align_of_val(&*ptr))
+                               min_align_of_val(&*ptr))
                 }
             }
         }