---

yaml
---
r: 161526
b: refs/heads/snap-stage3
c: 74fb798
h: refs/heads/master
v: v3

Author: nodakai

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 4eb72d268f337a8f117c86a2ac1b98336cab9e9d
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: ea8bb5d18d6bfff644631a1692eea1e429566298
+refs/heads/snap-stage3: 74fb798a200dc82cf5b4a18065e3ea565229adc3
 refs/heads/try: 0f0d21c1eb5c7be04d323e0b06faf252ad790af6
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/mk/crates.mk

@@ -53,8 +53,8 @@ TARGET_CRATES := libc std flate arena term \
                  serialize getopts collections test time rand \
                  log regex graphviz core rbml alloc rustrt \
                  unicode
-RUSTC_CRATES := rustc rustc_typeck rustc_driver rustc_trans rustc_back rustc_llvm 
-HOST_CRATES := syntax $(RUSTC_CRATES) rustdoc regex_macros fmt_macros
+HOST_CRATES := syntax rustc rustc_trans rustdoc regex_macros fmt_macros \
+	       rustc_llvm rustc_back
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
 
@@ -67,16 +67,12 @@ DEPS_std := core libc rand alloc collections rustrt unicode \
 	native:rust_builtin native:backtrace
 DEPS_graphviz := std
 DEPS_syntax := std term serialize log fmt_macros arena libc
-DEPS_rustc_driver := arena flate getopts graphviz libc rustc rustc_back \
-                     rustc_typeck log syntax serialize rustc_llvm rustc_trans
-DEPS_rustc_trans := arena flate getopts graphviz libc rustc rustc_back \
-	                log syntax serialize rustc_llvm
-DEPS_rustc_typeck := rustc syntax
+DEPS_rustc_trans := rustc rustc_back rustc_llvm libc
 DEPS_rustc := syntax flate arena serialize getopts rbml \
               time log graphviz rustc_llvm rustc_back
 DEPS_rustc_llvm := native:rustllvm libc std
 DEPS_rustc_back := std syntax rustc_llvm flate log libc
-DEPS_rustdoc := rustc rustc_driver native:hoedown serialize getopts \
+DEPS_rustdoc := rustc rustc_trans native:hoedown serialize getopts \
                 test time
 DEPS_flate := std native:miniz
 DEPS_arena := std
@@ -98,7 +94,7 @@ DEPS_fmt_macros = std
 
 TOOL_DEPS_compiletest := test getopts
 TOOL_DEPS_rustdoc := rustdoc
-TOOL_DEPS_rustc := rustc_driver
+TOOL_DEPS_rustc := rustc_trans
 TOOL_SOURCE_compiletest := $(S)src/compiletest/compiletest.rs
 TOOL_SOURCE_rustdoc := $(S)src/driver/driver.rs
 TOOL_SOURCE_rustc := $(S)src/driver/driver.rs
@@ -114,12 +110,8 @@ ONLY_RLIB_unicode := 1
 # You should not need to edit below this line
 ################################################################################
 
-DOC_CRATES := $(filter-out rustc, \
-              $(filter-out rustc_trans, \
-              $(filter-out rustc_typeck, \
-              $(filter-out rustc_driver, \
-              $(filter-out syntax, $(CRATES))))))
-COMPILER_DOC_CRATES := rustc rustc_trans rustc_typeck rustc_driver syntax
+DOC_CRATES := $(filter-out rustc, $(filter-out rustc_trans, $(filter-out syntax, $(CRATES))))
+COMPILER_DOC_CRATES := rustc rustc_trans syntax
 
 # This macro creates some simple definitions for each crate being built, just
 # some munging of all of the parameters above.

branches/snap-stage3/mk/tests.mk

@@ -21,7 +21,7 @@ $(eval $(call RUST_CRATE,coretest))
 
 TEST_TARGET_CRATES = $(filter-out core unicode,$(TARGET_CRATES)) coretest
 TEST_DOC_CRATES = $(DOC_CRATES)
-TEST_HOST_CRATES = $(filter-out rustc_typeck rustc_trans,$(HOST_CRATES))
+TEST_HOST_CRATES = $(HOST_CRATES)
 TEST_CRATES = $(TEST_TARGET_CRATES) $(TEST_HOST_CRATES)
 
 ######################################################################

branches/snap-stage3/src/doc/reference.md

@@ -522,7 +522,7 @@ The two values of the boolean type are written `true` and `false`.
 ### Symbols
 
 ```{.ebnf .gram}
-symbol : "::" | "->"
+symbol : "::" "->"
        | '#' | '[' | ']' | '(' | ')' | '{' | '}'
        | ',' | ';' ;
 ```

branches/snap-stage3/src/driver/driver.rs

@@ -12,6 +12,6 @@
 extern crate "rustdoc" as this;
 
 #[cfg(rustc)]
-extern crate "rustc_driver" as this;
+extern crate "rustc_trans" as this;
 
 fn main() { this::main() }

branches/snap-stage3/src/etc/licenseck.py

@@ -38,8 +38,9 @@
     "rt/isaac/randport.cpp", # public domain
     "rt/isaac/rand.h", # public domain
     "rt/isaac/standard.h", # public domain
-    "libstd/comm/mpsc_queue.rs", # BSD
-    "libstd/comm/spsc_queue.rs", # BSD
+    "libstd/sync/mpsc_queue.rs", # BSD
+    "libstd/sync/spsc_queue.rs", # BSD
+    "libstd/sync/mpmc_bounded_queue.rs", # BSD
     "test/bench/shootout-binarytrees.rs", # BSD
     "test/bench/shootout-chameneos-redux.rs", # BSD
     "test/bench/shootout-fannkuch-redux.rs", # BSD

branches/snap-stage3/src/etc/rustup.sh

@@ -188,7 +188,7 @@ flag() {
      fi
 }
 
-validate_opt() {
+validate_opt () {
     for arg in $CFG_ARGS
     do
         isArgValid=0
@@ -230,7 +230,6 @@ validate_opt() {
 }
 
 probe_need CFG_CURL  curl
-probe_need CFG_TAR   tar
 
 CFG_SRC_DIR="$(cd $(dirname $0) && pwd)/"
 CFG_SELF="$0"
@@ -389,109 +388,89 @@ esac
 
 msg "host triple: ${HOST_TRIPLE}"
 
-CFG_INSTALL_FLAGS=""
-if [ -n "${CFG_UNINSTALL}" ]
-then
-    CFG_INSTALL_FLAGS="${CFG_INSTALL_FLAGS} --uninstall"
-fi
-
-if [ -n "${CFG_PREFIX}" ]
-then
-    CFG_INSTALL_FLAGS="${CFG_INSTALL_FLAGS} --prefix=${CFG_PREFIX}"
-fi
-
-CFG_TMP_DIR="./rustup-tmp-install"
+PACKAGE_NAME=rust-nightly
+PACKAGE_NAME_AND_TRIPLE="${PACKAGE_NAME}-${HOST_TRIPLE}"
+TARBALL_NAME="${PACKAGE_NAME_AND_TRIPLE}.tar.gz"
+REMOTE_TARBALL="https://static.rust-lang.org/dist/${TARBALL_NAME}"
+TMP_DIR="./rustup-tmp-install"
+LOCAL_TARBALL="${TMP_DIR}/${TARBALL_NAME}"
+LOCAL_INSTALL_DIR="${TMP_DIR}/${PACKAGE_NAME_AND_TRIPLE}"
+LOCAL_INSTALL_SCRIPT="${LOCAL_INSTALL_DIR}/install.sh"
 
-RUST_URL="https://static.rust-lang.org/dist"
-RUST_PACKAGE_NAME=rust-nightly
-RUST_PACKAGE_NAME_AND_TRIPLE="${RUST_PACKAGE_NAME}-${HOST_TRIPLE}"
-RUST_TARBALL_NAME="${RUST_PACKAGE_NAME_AND_TRIPLE}.tar.gz"
-RUST_LOCAL_INSTALL_DIR="${CFG_TMP_DIR}/${RUST_PACKAGE_NAME_AND_TRIPLE}"
-RUST_LOCAL_INSTALL_SCRIPT="${RUST_LOCAL_INSTALL_DIR}/install.sh"
-
-CARGO_URL="https://static.rust-lang.org/cargo-dist"
 CARGO_PACKAGE_NAME=cargo-nightly
 CARGO_PACKAGE_NAME_AND_TRIPLE="${CARGO_PACKAGE_NAME}-${HOST_TRIPLE}"
 CARGO_TARBALL_NAME="${CARGO_PACKAGE_NAME_AND_TRIPLE}.tar.gz"
-CARGO_LOCAL_INSTALL_DIR="${CFG_TMP_DIR}/${CARGO_PACKAGE_NAME_AND_TRIPLE}"
+CARGO_REMOTE_TARBALL="https://static.rust-lang.org/cargo-dist/${CARGO_TARBALL_NAME}"
+CARGO_LOCAL_TARBALL="${TMP_DIR}/${CARGO_TARBALL_NAME}"
+CARGO_LOCAL_INSTALL_DIR="${TMP_DIR}/${CARGO_PACKAGE_NAME_AND_TRIPLE}"
 CARGO_LOCAL_INSTALL_SCRIPT="${CARGO_LOCAL_INSTALL_DIR}/install.sh"
 
-# Fetch the package.
-download_package() {
-    remote_tarball="$1"
-    local_tarball="$2"
+rm -Rf "${TMP_DIR}"
+need_ok "failed to remove temporary installation directory"
 
-    msg "Downloading ${remote_tarball} to ${local_tarball}"
+mkdir -p "${TMP_DIR}"
+need_ok "failed to create create temporary installation directory"
 
-    mkdir -p "${CFG_TMP_DIR}"
-    need_ok "failed to create create download directory"
+msg "downloading rust installer"
+"${CFG_CURL}" "${REMOTE_TARBALL}" > "${LOCAL_TARBALL}"
+if [ $? -ne 0 ]
+then
+        rm -Rf "${TMP_DIR}"
+        err "failed to download installer"
+fi
 
-    "${CFG_CURL}" -f -o "${local_tarball}" "${remote_tarball}"
+if [ -z "${CFG_DISABLE_CARGO}" ]; then
+    msg "downloading cargo installer"
+    "${CFG_CURL}" "${CARGO_REMOTE_TARBALL}" > "${CARGO_LOCAL_TARBALL}"
     if [ $? -ne 0 ]
     then
-        rm -Rf "${CFG_TMP_DIR}"
-        err "failed to download installer"
+            rm -Rf "${TMP_DIR}"
+            err "failed to download cargo installer"
     fi
-}
+fi
 
-# Wrap all the commands needed to install a package.
-install_package() {
-    tarball_name="$1"
-    install_script="$2"
 
-    msg "Extracting ${tarball_name}"
-    (cd "${CFG_TMP_DIR}" && "${CFG_TAR}" -xvf "${tarball_name}")
-    if [ $? -ne 0 ]; then
-        rm -Rf "${CFG_TMP_DIR}"
+(cd "${TMP_DIR}" && tar xzf "${TARBALL_NAME}")
+if [ $? -ne 0 ]
+then
+        rm -Rf "${TMP_DIR}"
         err "failed to unpack installer"
-    fi
+fi
 
-    sh "${install_script}" "${CFG_INSTALL_FLAGS}"
-    if [ $? -ne 0 ]
-    then
-        rm -Rf "${CFG_TMP_DIR}"
-        err "failed to install Rust"
-    fi
-}
+MAYBE_UNINSTALL=
+if [ -n "${CFG_UNINSTALL}" ]
+then
+        MAYBE_UNINSTALL="--uninstall"
+fi
 
-# It's possible that curl could be interrupted partway though downloading
-# `rustup.sh`, truncating the file. This could be especially bad if we were in
-# the middle of a line that would run "rm -rf ". To protect against this, we
-# wrap up the `rustup.sh` destructive functionality in this helper function,
-# which we call as the last thing we do. This means we will not do anything
-# unless we have the entire file downloaded.
-install_packages() {
-    rm -Rf "${CFG_TMP_DIR}"
-    need_ok "failed to remove temporary installation directory"
-
-    mkdir -p "${CFG_TMP_DIR}"
-    need_ok "failed to create create temporary installation directory"
-
-    RUST_LOCAL_TARBALL="${CFG_TMP_DIR}/${RUST_TARBALL_NAME}"
-    CARGO_LOCAL_TARBALL="${CFG_TMP_DIR}/${CARGO_TARBALL_NAME}"
-
-    download_package \
-        "${RUST_URL}/${RUST_TARBALL_NAME}" \
-        "${RUST_LOCAL_TARBALL}"
-
-    if [ -z "${CFG_DISABLE_CARGO}" ]; then
-        download_package \
-            "${CARGO_URL}/${CARGO_TARBALL_NAME}" \
-            "${CARGO_LOCAL_TARBALL}"
-    fi
+MAYBE_PREFIX=
+if [ -n "${CFG_PREFIX}" ]
+then
+        MAYBE_PREFIX="--prefix=${CFG_PREFIX}"
+fi
 
-    install_package \
-        "${RUST_TARBALL_NAME}" \
-        "${RUST_LOCAL_INSTALL_SCRIPT}"
+sh "${LOCAL_INSTALL_SCRIPT}" "${MAYBE_UNINSTALL}" "${MAYBE_PREFIX}"
+if [ $? -ne 0 ]
+then
+        rm -Rf "${TMP_DIR}"
+        err "failed to install Rust"
+fi
 
-    if [ -z "${CFG_DISABLE_CARGO}" ]; then
-        install_package \
-            "${CARGO_TARBALL_NAME}" \
-            "${CARGO_LOCAL_INSTALL_SCRIPT}"
+if [ -z "${CFG_DISABLE_CARGO}" ]; then
+    (cd "${TMP_DIR}" && tar xzf "${CARGO_TARBALL_NAME}")
+    if [ $? -ne 0 ]
+    then
+            rm -Rf "${TMP_DIR}"
+            err "failed to unpack cargo installer"
     fi
 
-    rm -Rf "${CFG_TMP_DIR}"
-    need_ok "couldn't rm temporary installation directory"
-}
+    sh "${CARGO_LOCAL_INSTALL_SCRIPT}" "${MAYBE_UNINSTALL}" "${MAYBE_PREFIX}"
+    if [ $? -ne 0 ]
+    then
+            rm -Rf "${TMP_DIR}"
+            err "failed to install Cargo"
+    fi
+fi
 
-install_packages
+rm -Rf "${TMP_DIR}"
+need_ok "couldn't rm temporary installation directory"

branches/snap-stage3/src/libcollections/dlist.rs

@@ -945,15 +945,15 @@ mod tests {
         let mut m = list_from(v.as_slice());
         m.rotate_backward(); check_links(&m);
         m.rotate_forward(); check_links(&m);
-        assert_eq!(v.iter().collect::<Vec<&int>>(), m.iter().collect::<Vec<_>>());
+        assert_eq!(v.iter().collect::<Vec<&int>>(), m.iter().collect());
         m.rotate_forward(); check_links(&m);
         m.rotate_forward(); check_links(&m);
         m.pop_front(); check_links(&m);
         m.rotate_forward(); check_links(&m);
         m.rotate_backward(); check_links(&m);
         m.push_front(9); check_links(&m);
         m.rotate_forward(); check_links(&m);
-        assert_eq!(vec![3i,9,5,1,2], m.into_iter().collect::<Vec<_>>());
+        assert_eq!(vec![3i,9,5,1,2], m.into_iter().collect());
     }
 
     #[test]

branches/snap-stage3/src/libcollections/enum_set.rs

@@ -397,23 +397,23 @@ mod test {
     fn test_iterator() {
         let mut e1: EnumSet<Foo> = EnumSet::new();
 
-        let elems: ::vec::Vec<Foo> = e1.iter().collect();
+        let elems: Vec<Foo> = e1.iter().collect();
         assert!(elems.is_empty())
 
         e1.insert(A);
-        let elems: ::vec::Vec<_> = e1.iter().collect();
+        let elems = e1.iter().collect();
         assert_eq!(vec![A], elems)
 
         e1.insert(C);
-        let elems: ::vec::Vec<_> = e1.iter().collect();
+        let elems = e1.iter().collect();
         assert_eq!(vec![A,C], elems)
 
         e1.insert(C);
-        let elems: ::vec::Vec<_> = e1.iter().collect();
+        let elems = e1.iter().collect();
         assert_eq!(vec![A,C], elems)
 
         e1.insert(B);
-        let elems: ::vec::Vec<_> = e1.iter().collect();
+        let elems = e1.iter().collect();
         assert_eq!(vec![A,B,C], elems)
     }
 
@@ -431,35 +431,35 @@ mod test {
         e2.insert(C);
 
         let e_union = e1 | e2;
-        let elems: ::vec::Vec<_> = e_union.iter().collect();
+        let elems = e_union.iter().collect();
         assert_eq!(vec![A,B,C], elems)
 
         let e_intersection = e1 & e2;
-        let elems: ::vec::Vec<_> = e_intersection.iter().collect();
+        let elems = e_intersection.iter().collect();
         assert_eq!(vec![C], elems)
 
         // Another way to express intersection
         let e_intersection = e1 - (e1 - e2);
-        let elems: ::vec::Vec<_> = e_intersection.iter().collect();
+        let elems = e_intersection.iter().collect();
         assert_eq!(vec![C], elems)
 
         let e_subtract = e1 - e2;
-        let elems: ::vec::Vec<_> = e_subtract.iter().collect();
+        let elems = e_subtract.iter().collect();
         assert_eq!(vec![A], elems)
 
         // Bitwise XOR of two sets, aka symmetric difference
         let e_symmetric_diff = e1 ^ e2;
-        let elems: ::vec::Vec<_> = e_symmetric_diff.iter().collect();
+        let elems = e_symmetric_diff.iter().collect();
         assert_eq!(vec![A,B], elems)
 
         // Another way to express symmetric difference
         let e_symmetric_diff = (e1 - e2) | (e2 - e1);
-        let elems: ::vec::Vec<_> = e_symmetric_diff.iter().collect();
+        let elems = e_symmetric_diff.iter().collect();
         assert_eq!(vec![A,B], elems)
 
         // Yet another way to express symmetric difference
         let e_symmetric_diff = (e1 | e2) - (e1 & e2);
-        let elems: ::vec::Vec<_> = e_symmetric_diff.iter().collect();
+        let elems = e_symmetric_diff.iter().collect();
         assert_eq!(vec![A,B], elems)
     }
 

branches/snap-stage3/src/libcollections/str.rs

@@ -563,7 +563,6 @@ impl<'a> Ord for MaybeOwned<'a> {
     }
 }
 
-#[allow(deprecated)]
 #[deprecated = "use std::str::CowString"]
 impl<'a, S: Str> Equiv<S> for MaybeOwned<'a> {
     #[inline]