---

yaml
---
r: 162794
b: refs/heads/try
c: 7c44561
h: refs/heads/master
v: v3

Author: nikomatsakis

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 9146a919b616e39e528e4d7100d16eef52f1f852
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cafe2966770ff377aad6dd9fd808e68055587c58
-refs/heads/try: 361baabb07b2fb921d0f556d0787b3ea7ef86746
+refs/heads/try: 7c44561ad6f4651047255d0c630a0c3f80c3fdd4
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/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/try/src/libcore/result.rs

@@ -444,14 +444,15 @@ impl<T, E> Result<T, E> {
     /// ignoring I/O and parse errors:
     ///
     /// ```
-    /// use std::io::IoResult;
+    /// use std::io::{BufReader, IoResult};
     ///
-    /// let mut buffer = &mut b"1\n2\n3\n4\n";
+    /// let buffer = "1\n2\n3\n4\n";
+    /// let mut reader = BufReader::new(buffer.as_bytes());
     ///
     /// let mut sum = 0;
     ///
-    /// while !buffer.is_empty() {
-    ///     let line: IoResult<String> = buffer.read_line();
+    /// while !reader.eof() {
+    ///     let line: IoResult<String> = reader.read_line();
     ///     // Convert the string line to a number using `map` and `from_str`
     ///     let val: IoResult<int> = line.map(|line| {
     ///         from_str::<int>(line.as_slice().trim_right()).unwrap_or(0)

branches/try/src/libgraphviz/lib.rs

@@ -547,7 +547,7 @@ mod tests {
     use self::NodeLabels::*;
     use super::{Id, LabelText, LabelStr, EscStr, Labeller};
     use super::{Nodes, Edges, GraphWalk, render};
-    use std::io::IoResult;
+    use std::io::{BufReader, IoResult};
     use std::str;
 
     /// each node is an index in a vector in the graph.
@@ -698,7 +698,8 @@ mod tests {
     fn test_input(g: LabelledGraph) -> IoResult<String> {
         let mut writer = Vec::new();
         render(&g, &mut writer).unwrap();
-        (&mut writer.as_slice()).read_to_string()
+        let mut r = BufReader::new(writer[]);
+        r.read_to_string()
     }
 
     // All of the tests use raw-strings as the format for the expected outputs,
@@ -810,7 +811,8 @@ r#"digraph hasse_diagram {
                  edge(1, 3, ";"),    edge(2, 3, ";"   )));
 
         render(&g, &mut writer).unwrap();
-        let r = (&mut writer.as_slice()).read_to_string();
+        let mut r = BufReader::new(writer[]);
+        let r = r.read_to_string();
 
         assert_eq!(r.unwrap().as_slice(),
 r#"digraph syntax_tree {

branches/try/src/librustc/lint/builtin.rs

@@ -30,7 +30,7 @@ use metadata::csearch;
 use middle::def::*;
 use middle::ty::{mod, Ty};
 use middle::typeck::astconv::ast_ty_to_ty;
-use middle::typeck::{mod, infer};
+use middle::typeck::infer;
 use middle::{def, pat_util, stability};
 use middle::const_eval::{eval_const_expr_partial, const_int, const_uint};
 use util::ppaux::{ty_to_string};
@@ -1589,22 +1589,22 @@ impl LintPass for Stability {
             }
             ast::ExprMethodCall(i, _, _) => {
                 span = i.span;
-                let method_call = typeck::MethodCall::expr(e.id);
+                let method_call = ty::MethodCall::expr(e.id);
                 match cx.tcx.method_map.borrow().get(&method_call) {
                     Some(method) => {
                         match method.origin {
-                            typeck::MethodStatic(def_id) => {
+                            ty::MethodStatic(def_id) => {
                                 def_id
                             }
-                            typeck::MethodStaticUnboxedClosure(def_id) => {
+                            ty::MethodStaticUnboxedClosure(def_id) => {
                                 def_id
                             }
-                            typeck::MethodTypeParam(typeck::MethodParam {
+                            ty::MethodTypeParam(ty::MethodParam {
                                 ref trait_ref,
                                 method_num: index,
                                 ..
                             }) |
-                            typeck::MethodTraitObject(typeck::MethodObject {
+                            ty::MethodTraitObject(ty::MethodObject {
                                 ref trait_ref,
                                 method_num: index,
                                 ..

branches/try/src/librustc/metadata/csearch.rs

@@ -21,7 +21,6 @@ use middle::def;
 use middle::lang_items;
 use middle::resolve;
 use middle::ty;
-use middle::typeck;
 use middle::subst::VecPerParamSpace;
 
 use rbml;
@@ -268,7 +267,7 @@ pub fn get_impl_trait<'tcx>(tcx: &ty::ctxt<'tcx>,
 // Given a def_id for an impl, return information about its vtables
 pub fn get_impl_vtables<'tcx>(tcx: &ty::ctxt<'tcx>,
                               def: ast::DefId)
-                              -> typeck::vtable_res<'tcx> {
+                              -> ty::vtable_res<'tcx> {
     let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_impl_vtables(&*cdata, def.node, tcx)

branches/try/src/librustc/metadata/decoder.rs

@@ -30,7 +30,6 @@ use middle::resolve::{TraitItemKind, TypeTraitItemKind};
 use middle::subst;
 use middle::ty::{ImplContainer, TraitContainer};
 use middle::ty::{mod, Ty};
-use middle::typeck;
 use middle::astencode::vtable_decoder_helpers;
 
 use std::hash::Hash;
@@ -422,7 +421,7 @@ pub fn get_impl_trait<'tcx>(cdata: Cmd,
 pub fn get_impl_vtables<'tcx>(cdata: Cmd,
                               id: ast::NodeId,
                               tcx: &ty::ctxt<'tcx>)
-                              -> typeck::vtable_res<'tcx>
+                              -> ty::vtable_res<'tcx>
 {
     let item_doc = lookup_item(id, cdata.data());
     let vtables_doc = reader::get_doc(item_doc, tag_item_impl_vtables);