---

yaml
---
r: 102085
b: refs/heads/master
c: a0f0699
h: refs/heads/master
i:
  102083: bdc52c9
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 4687e1d67d2601c3a408b74224f5ceb353c77b71
+refs/heads/master: a0f0699da68d8b4712035e3b5b42990af2df9cfb
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6e7f170fedd3c526a643c0b2d13863acd982be02
 refs/heads/try: a97642026c18a624ff6ea01075dd9550f8ed07ff

trunk/.travis.yml

@@ -0,0 +1,53 @@
+# Use something that's not 'ruby' so we don't set up things like
+# RVM/bundler/ruby and whatnot. Right now 'rust' isn't a language on travis and
+# it treats unknown languages as ruby-like I believe.
+language: c
+
+# Before we start doing anything, install the latest stock LLVM. These are
+# maintained by LLVM, and more information can be found at llvm.org/apt.
+#
+# Right now, the highest version is 3.5, and our SVN version is roughly aligned
+# with the 3.5 API (hurray!)
+install:
+  - sudo sh -c "echo 'deb http://llvm.org/apt/precise/ llvm-toolchain-precise main' >> /etc/apt/sources.list"
+  - sudo sh -c "echo 'deb-src http://llvm.org/apt/precise/ llvm-toolchain-precise main' >> /etc/apt/sources.list"
+  - sudo sh -c "echo 'deb http://ppa.launchpad.net/ubuntu-toolchain-r/test/ubuntu precise main' >> /etc/apt/sources.list"
+  - wget -O - http://llvm.org/apt/llvm-snapshot.gpg.key | sudo apt-key add -
+  - sudo apt-get update -qq
+  - sudo apt-get install -y --force-yes -qq llvm-3.5 llvm-3.5-dev clang-3.5 lldb-3.5
+
+# All of the llvm tools are suffixed with "-3.5" which we don't want, so symlink
+# them all into a local directory and just use that
+#
+# FIXME: this shouldn't update the src/llvm sub-repo, that takes about a minute
+#        it's gotta download so much stuff.
+before_script:
+  - mkdir -p local-llvm/bin
+  - ln -nsf /usr/bin/llvm-config-3.5 local-llvm/bin/llvm-config
+  - ln -nsf /usr/bin/llvm-mc-3.5 local-llvm/bin/llvm-mc
+  - ln -nsf /usr/bin/llvm-as-3.5 local-llvm/bin/llvm-as
+  - ln -nsf /usr/bin/llvm-dis-3.5 local-llvm/bin/llvm-dis
+  - ln -nsf /usr/bin/llc-3.5 local-llvm/bin/llc
+  - ln -nsf /usr/include/llvm-3.5 local-llvm/include
+  - ./configure --disable-optimize-tests --llvm-root=`pwd`/local-llvm --enable-fast-make --enable-clang
+
+# Tidy everything up first, then build a few things, and then run a few tests.
+# Note that this is meant to run in a "fairly small" amount of time, so this
+# isn't exhaustive at all.
+#
+# The "-lffi and -lncurses" are required for LLVM. The LLVM that rust builds
+# manually disables bringing in these two libraries, but the stock LLVM was
+# apparently built with these options. We provide these options when building so
+# the `rustc` binary can successfully link.
+script:
+  - make tidy
+  - RUSTFLAGS="-C link-args='-lffi -lncurses'" make -j4 rustc-stage1
+  - make check-stage1-std check-stage1-rpass check-stage1-cfail check-stage1-rfail
+
+env:
+  - NO_BENCH=1
+
+# We track this ourselves, and in theory we don't have to update the LLVM repo
+# (but sadly we do right now anyway).
+git:
+  submodules: false

trunk/configure

@@ -604,7 +604,7 @@ then
     LLVM_VERSION=$($LLVM_CONFIG --version)
 
     case $LLVM_VERSION in
-        (3.[2-4]svn|3.[2-4])
+        (3.[2-5]svn|3.[2-5])
             msg "found ok version of LLVM: $LLVM_VERSION"
             ;;
         (*)
@@ -626,7 +626,7 @@ then
                       | cut -d ' ' -f 2)
 
     case $CFG_CLANG_VERSION in
-        (3.0svn | 3.0 | 3.1* | 3.2* | 3.3* | 3.4* )
+        (3.0svn | 3.0 | 3.1* | 3.2* | 3.3* | 3.4* | 3.5* )
         step_msg "found ok version of CLANG: $CFG_CLANG_VERSION"
         CFG_C_COMPILER="clang"
         ;;

trunk/mk/main.mk

@@ -218,8 +218,12 @@ LLVM_TOOLS=bugpoint llc llvm-ar llvm-as llvm-dis llvm-mc opt llvm-extract
 define DEF_LLVM_VARS
 # The configure script defines these variables with the target triples
 # separated by Z. This defines new ones with the expected format.
+ifeq ($$(CFG_LLVM_ROOT),)
 CFG_LLVM_BUILD_DIR_$(1):=$$(CFG_LLVM_BUILD_DIR_$(subst -,_,$(1)))
 CFG_LLVM_INST_DIR_$(1):=$$(CFG_LLVM_INST_DIR_$(subst -,_,$(1)))
+else
+CFG_LLVM_INST_DIR_$(1):=$$(CFG_LLVM_ROOT)
+endif
 
 # Any rules that depend on LLVM should depend on LLVM_CONFIG
 LLVM_CONFIG_$(1):=$$(CFG_LLVM_INST_DIR_$(1))/bin/llvm-config$$(X_$(1))

trunk/mk/prepare.mk

@@ -16,7 +16,7 @@
 #
 # It requires the following variables to be set:
 #
-#   PREPARE_HOST - the host triple 
+#   PREPARE_HOST - the host triple
 #   PREPARE_TARGETS - the target triples, space separated
 #   PREPARE_DEST_DIR - the directory to put the image
 
@@ -172,7 +172,10 @@ prepare-target-$(2)-host-$(3)-$(1): \
         $$(if $$(findstring $(2),$$(CFG_HOST)), \
           $$(foreach crate,$$(HOST_CRATES), \
             $$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$$(crate)),)
-# Only install if this host and target combo is being prepared
+# Only install if this host and target combo is being prepared. Also be sure to
+# *not* install the rlibs for host crates because there's no need to statically
+# link against most of them. They just produce a large amount of extra size
+# bloat.
 	$$(if $$(findstring $(1), $$(PREPARE_STAGE)),\
       $$(if $$(findstring $(2), $$(PREPARE_TARGETS)),\
         $$(if $$(findstring $(3), $$(PREPARE_HOST)),\
@@ -182,8 +185,7 @@ prepare-target-$(2)-host-$(3)-$(1): \
             $$(call PREPARE_LIB,$$(call CFG_RLIB_GLOB,$$(crate))))\
           $$(if $$(findstring $(2),$$(CFG_HOST)),\
             $$(foreach crate,$$(HOST_CRATES),\
-              $$(call PREPARE_LIB,$$(call CFG_LIB_GLOB_$(2),$$(crate)))\
-              $$(call PREPARE_LIB,$$(call CFG_RLIB_GLOB,$$(crate)))),)\
+              $$(call PREPARE_LIB,$$(call CFG_LIB_GLOB_$(2),$$(crate)))),)\
           $$(call PREPARE_LIB,libmorestack.a) \
           $$(call PREPARE_LIB,libcompiler-rt.a),),),)
 endef

trunk/src/etc/generate-deriving-span-tests.py

@@ -119,7 +119,8 @@ def write_file(name, string):
                               ('Clone', [], 1), ('DeepClone', ['Clone'], 1),
                               ('Eq', [], 2), ('Ord', [], 8),
                               ('TotalEq', [], 1), ('TotalOrd', ['TotalEq'], 1),
-                              ('Show', [], 1)]:
+                              ('Show', [], 1),
+                              ('Hash', [], 1)]:
     traits[trait] = (ALL, supers, errs)
 
 for (trait, (types, super_traits, error_count)) in traits.items():

trunk/src/libextra/stats.rs

@@ -11,6 +11,7 @@
 #[allow(missing_doc)];
 
 use std::cmp;
+use std::hash_old::Hash;
 use std::hashmap;
 use std::io;
 use std::mem;

trunk/src/librustc/back/link.rs

@@ -34,6 +34,7 @@ use std::run;
 use std::str;
 use std::io;
 use std::io::fs;
+use flate;
 use serialize::hex::ToHex;
 use extra::tempfile::TempDir;
 use syntax::abi;
@@ -942,6 +943,15 @@ fn link_rlib(sess: Session,
             // For LTO purposes, the bytecode of this library is also inserted
             // into the archive.
             let bc = obj_filename.with_extension("bc");
+            match fs::File::open(&bc).read_to_end().and_then(|data| {
+                fs::File::create(&bc).write(flate::deflate_bytes(data))
+            }) {
+                Ok(()) => {}
+                Err(e) => {
+                    sess.err(format!("failed to compress bytecode: {}", e));
+                    sess.abort_if_errors()
+                }
+            }
             a.add_file(&bc, false);
             if !sess.opts.cg.save_temps &&
                !sess.opts.output_types.contains(&OutputTypeBitcode) {

trunk/src/librustc/back/lto.rs

@@ -16,6 +16,7 @@ use metadata::cstore;
 use util::common::time;
 
 use std::libc;
+use flate;
 
 pub fn run(sess: session::Session, llmod: ModuleRef,
            tm: TargetMachineRef, reachable: &[~str]) {
@@ -55,6 +56,8 @@ pub fn run(sess: session::Session, llmod: ModuleRef,
         let bc = time(sess.time_passes(), format!("read {}.bc", name), (), |_|
                       archive.read(format!("{}.bc", name)));
         let bc = bc.expect("missing bytecode in archive!");
+        let bc = time(sess.time_passes(), format!("inflate {}.bc", name), (), |_|
+                      flate::inflate_bytes(bc));
         let ptr = bc.as_ptr();
         debug!("linking {}", name);
         time(sess.time_passes(), format!("ll link {}", name), (), |()| unsafe {

trunk/src/librustc/metadata/decoder.rs

@@ -27,6 +27,7 @@ use middle::typeck;
 use middle::astencode::vtable_decoder_helpers;
 
 use std::u64;
+use std::hash_old::Hash;
 use std::io;
 use std::io::extensions::u64_from_be_bytes;
 use std::option;

trunk/src/librustc/metadata/encoder.rs

@@ -26,6 +26,7 @@ use middle;
 use serialize::Encodable;
 use std::cast;
 use std::cell::{Cell, RefCell};
+use std::hash_old::Hash;
 use std::hashmap::{HashMap, HashSet};
 use std::io::MemWriter;
 use std::str;

trunk/src/librustc/metadata/loader.rs

@@ -407,11 +407,8 @@ fn get_metadata_section_imp(os: Os, filename: &Path) -> Option<MetadataBlob> {
                 debug!("checking {} bytes of metadata-version stamp",
                        vlen);
                 let minsz = cmp::min(vlen, csz);
-                let mut version_ok = false;
-                vec::raw::buf_as_slice(cvbuf, minsz, |buf0| {
-                    version_ok = (buf0 ==
-                                  encoder::metadata_encoding_version);
-                });
+                let version_ok = vec::raw::buf_as_slice(cvbuf, minsz,
+                    |buf0| buf0 == encoder::metadata_encoding_version);
                 if !version_ok { return None; }
 
                 let cvbuf1 = cvbuf.offset(vlen as int);

trunk/src/librustc/middle/borrowck/gather_loans/lifetime.rs

@@ -95,11 +95,10 @@ impl<'a> GuaranteeLifetimeContext<'a> {
                 let base_scope = self.scope(base);
 
                 // L-Deref-Managed-Imm-User-Root
-                let omit_root = (
+                let omit_root =
                     self.bccx.is_subregion_of(self.loan_region, base_scope) &&
                     self.is_rvalue_or_immutable(base) &&
-                    !self.is_moved(base)
-                );
+                    !self.is_moved(base);
 
                 if !omit_root {
                     // L-Deref-Managed-Imm-Compiler-Root

trunk/src/librustc/middle/dataflow.rs

@@ -891,7 +891,7 @@ fn bitwise(out_vec: &mut [uint], in_vec: &[uint], op: |uint, uint| -> uint)
         let old_val = *out_elt;
         let new_val = op(old_val, *in_elt);
         *out_elt = new_val;
-        changed |= (old_val != new_val);
+        changed |= old_val != new_val;
     }
     changed
 }

trunk/src/librustc/middle/lint.rs

@@ -1167,22 +1167,41 @@ fn check_pat_non_uppercase_statics(cx: &Context, p: &ast::Pat) {
     }
 }
 
-fn check_unnecessary_parens(cx: &Context, e: &ast::Expr) {
+fn check_unnecessary_parens_core(cx: &Context, value: &ast::Expr, msg: &str) {
+    match value.node {
+        ast::ExprParen(_) => {
+            cx.span_lint(UnnecessaryParens, value.span,
+                         format!("unnecessary parentheses around {}", msg))
+        }
+        _ => {}
+    }
+}
+
+fn check_unnecessary_parens_expr(cx: &Context, e: &ast::Expr) {
     let (value, msg) = match e.node {
         ast::ExprIf(cond, _, _) => (cond, "`if` condition"),
         ast::ExprWhile(cond, _) => (cond, "`while` condition"),
         ast::ExprMatch(head, _) => (head, "`match` head expression"),
         ast::ExprRet(Some(value)) => (value, "`return` value"),
+        ast::ExprAssign(_, value) => (value, "assigned value"),
+        ast::ExprAssignOp(_, _, _, value) => (value, "assigned value"),
         _ => return
     };
+    check_unnecessary_parens_core(cx, value, msg);
+}
 
-    match value.node {
-        ast::ExprParen(_) => {
-            cx.span_lint(UnnecessaryParens, value.span,
-                         format!("unnecessary parentheses around {}", msg))
-        }
-        _ => {}
-    }
+fn check_unnecessary_parens_stmt(cx: &Context, s: &ast::Stmt) {
+    let (value, msg) = match s.node {
+        ast::StmtDecl(decl, _) => match decl.node {
+            ast::DeclLocal(local) => match local.init {
+                Some(value) => (value, "assigned value"),
+                None => return
+            },
+            _ => return
+        },
+        _ => return
+    };
+    check_unnecessary_parens_core(cx, value, msg);
 }
 
 fn check_unused_unsafe(cx: &Context, e: &ast::Expr) {
@@ -1534,7 +1553,7 @@ impl<'a> Visitor<()> for Context<'a> {
 
         check_while_true_expr(self, e);
         check_stability(self, e);
-        check_unnecessary_parens(self, e);
+        check_unnecessary_parens_expr(self, e);
         check_unused_unsafe(self, e);
         check_unsafe_block(self, e);
         check_unnecessary_allocation(self, e);
@@ -1549,6 +1568,7 @@ impl<'a> Visitor<()> for Context<'a> {
     fn visit_stmt(&mut self, s: &ast::Stmt, _: ()) {
         check_path_statement(self, s);
         check_unused_result(self, s);
+        check_unnecessary_parens_stmt(self, s);
 
         visit::walk_stmt(self, s, ());
     }

trunk/src/librustc/middle/reachable.rs

@@ -404,11 +404,23 @@ pub fn find_reachable(tcx: ty::ctxt,
     let reachable_context = ReachableContext::new(tcx, method_map);
 
     // Step 1: Seed the worklist with all nodes which were found to be public as
-    //         a result of the privacy pass
+    //         a result of the privacy pass along with all local lang items. If
+    //         other crates link to us, they're going to expect to be able to
+    //         use the lang items, so we need to be sure to mark them as
+    //         exported.
+    let mut worklist = reachable_context.worklist.borrow_mut();
     for &id in exported_items.iter() {
-        let mut worklist = reachable_context.worklist.borrow_mut();
         worklist.get().push(id);
     }
+    for (_, item) in tcx.lang_items.items() {
+        match *item {
+            Some(did) if is_local(did) => {
+                worklist.get().push(did.node);
+            }
+            _ => {}
+        }
+    }
+    drop(worklist);
 
     // Step 2: Mark all symbols that the symbols on the worklist touch.
     reachable_context.propagate();

trunk/src/librustc/middle/trans/monomorphize.rs

@@ -143,10 +143,8 @@ pub fn monomorphic_fn(ccx: @CrateContext,
             // This is a bit unfortunate.
 
             let idx = psubsts.tys.len() - num_method_ty_params;
-            let substs =
-                (psubsts.tys.slice(0, idx) +
-                 &[psubsts.self_ty.unwrap()] +
-                 psubsts.tys.tailn(idx));
+            let substs = psubsts.tys.slice(0, idx) +
+                &[psubsts.self_ty.unwrap()] + psubsts.tys.tailn(idx);
             debug!("static default: changed substitution to {}",
                    substs.repr(ccx.tcx));
 

trunk/src/librustc/middle/ty.rs

@@ -2293,8 +2293,8 @@ pub fn type_contents(cx: ctxt, ty: t) -> TypeContents {
                        bounds: BuiltinBounds)
                        -> TypeContents {
         // These are the type contents of the (opaque) interior
-        let contents = (TC::ReachesMutable.when(mutbl == ast::MutMutable) |
-                        kind_bounds_to_contents(cx, bounds, []));
+        let contents = TC::ReachesMutable.when(mutbl == ast::MutMutable) |
+            kind_bounds_to_contents(cx, bounds, []);
 
         match store {
             UniqTraitStore => {
@@ -3691,15 +3691,15 @@ pub fn type_err_to_str(cx: ctxt, err: &type_err) -> ~str {
             }
         }
         terr_integer_as_char => {
-            format!("expected an integral type but found char")
+            format!("expected an integral type but found `char`")
         }
         terr_int_mismatch(ref values) => {
-            format!("expected {} but found {}",
+            format!("expected `{}` but found `{}`",
                  values.expected.to_str(),
                  values.found.to_str())
         }
         terr_float_mismatch(ref values) => {
-            format!("expected {} but found {}",
+            format!("expected `{}` but found `{}`",
                  values.expected.to_str(),
                  values.found.to_str())
         }
@@ -3767,13 +3767,13 @@ pub fn provided_trait_methods(cx: ctxt, id: ast::DefId) -> ~[@Method] {
                         }
                         _ => {
                             cx.sess.bug(format!("provided_trait_methods: \
-                                                 {:?} is not a trait",
+                                                 `{:?}` is not a trait",
                                                 id))
                         }
                     }
                 }
                 _ => {
-                    cx.sess.bug(format!("provided_trait_methods: {:?} is not \
+                    cx.sess.bug(format!("provided_trait_methods: `{:?}` is not \
                                          a trait",
                                         id))
                 }
@@ -4916,7 +4916,7 @@ pub fn trait_method_of_method(tcx: ctxt,
 /// Creates a hash of the type `t` which will be the same no matter what crate
 /// context it's calculated within. This is used by the `type_id` intrinsic.
 pub fn hash_crate_independent(tcx: ctxt, t: t, local_hash: ~str) -> u64 {
-    use std::hash::{SipState, Streaming};
+    use std::hash_old::{SipState, Streaming};
 
     let mut hash = SipState::new(0, 0);
     let region = |_hash: &mut SipState, r: Region| {