---

yaml
---
r: 159535
b: refs/heads/auto
c: 351f7af
h: refs/heads/master
i:
  159533: 25a227e
  159531: 4470481
  159527: 9d3402b
  159519: 3480d80
v: v3

Author: bors

[refs]

@@ -10,7 +10,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 27774e8e24fe66b6463ca1916eeea1626c663e77
+refs/heads/auto: 351f7afd06d2164b5bfe2467333c355a20fcb02d
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/etc/make-win-dist.py

@@ -23,7 +23,7 @@ def find_files(files, path):
     return found
 
 def make_win_dist(dist_root, target_triple):
-    # Ask gcc where it keeps its' stuff
+    # Ask gcc where it keeps its stuff
     gcc_out = subprocess.check_output(["gcc.exe", "-print-search-dirs"])
     bin_path = os.environ["PATH"].split(os.pathsep)
     lib_path = []
@@ -42,11 +42,48 @@ def make_win_dist(dist_root, target_triple):
     else:
         rustc_dlls.append("libgcc_s_seh-1.dll")
 
-    target_libs = ["crtbegin.o", "crtend.o", "crt2.o", "dllcrt2.o",
-                   "libadvapi32.a", "libcrypt32.a", "libgcc.a", "libgcc_eh.a", "libgcc_s.a",
-                   "libimagehlp.a", "libiphlpapi.a", "libkernel32.a", "libm.a", "libmingw32.a",
-                   "libmingwex.a", "libmsvcrt.a", "libpsapi.a", "libshell32.a", "libstdc++.a",
-                   "libuser32.a", "libws2_32.a", "libiconv.a", "libmoldname.a"]
+    target_libs = [ # MinGW libs
+                    "crtbegin.o",
+                    "crtend.o",
+                    "crt2.o",
+                    "dllcrt2.o",
+                    "libgcc.a",
+                    "libgcc_eh.a",
+                    "libgcc_s.a",
+                    "libm.a",
+                    "libmingw32.a",
+                    "libmingwex.a",
+                    "libstdc++.a",
+                    "libiconv.a",
+                    "libmoldname.a",
+                    # Windows import libs
+                    "libadvapi32.a",
+                    "libbcrypt.a",
+                    "libcomctl32.a",
+                    "libcomdlg32.a",
+                    "libcrypt32.a",
+                    "libctl3d32.a",
+                    "libgdi32.a",
+                    "libimagehlp.a",
+                    "libiphlpapi.a",
+                    "libkernel32.a",
+                    "libmsvcrt.a",
+                    "libodbc32.a",
+                    "libole32.a",
+                    "liboleaut32.a",
+                    "libopengl32.a",
+                    "libpsapi.a",
+                    "librpcrt4.a",
+                    "libsetupapi.a",
+                    "libshell32.a",
+                    "libuser32.a",
+                    "libuuid.a",
+                    "libwinhttp.a",
+                    "libwinmm.a",
+                    "libwinspool.a",
+                    "libws2_32.a",
+                    "libwsock32.a",
+                    ]
 
     # Find mingw artifacts we want to bundle
     target_tools = find_files(target_tools, bin_path)
@@ -59,14 +96,14 @@ def make_win_dist(dist_root, target_triple):
         shutil.copy(src, dist_bin_dir)
 
     # Copy platform tools to platform-specific bin directory
-    target_bin_dir = os.path.join(dist_root, "bin", "rustlib", target_triple, "gcc", "bin")
+    target_bin_dir = os.path.join(dist_root, "bin", "rustlib", target_triple, "bin")
     if not os.path.exists(target_bin_dir):
         os.makedirs(target_bin_dir)
     for src in target_tools:
         shutil.copy(src, target_bin_dir)
 
     # Copy platform libs to platform-spcific lib directory
-    target_lib_dir = os.path.join(dist_root, "bin", "rustlib", target_triple, "gcc", "lib")
+    target_lib_dir = os.path.join(dist_root, "bin", "rustlib", target_triple, "lib")
     if not os.path.exists(target_lib_dir):
         os.makedirs(target_lib_dir)
     for src in target_libs:

branches/auto/src/etc/vim/syntax/rust.vim

@@ -23,14 +23,14 @@ syn keyword   rustKeyword     box nextgroup=rustBoxPlacement skipwhite skipempty
 syn keyword   rustKeyword     continue
 syn keyword   rustKeyword     extern nextgroup=rustExternCrate,rustObsoleteExternMod skipwhite skipempty
 syn keyword   rustKeyword     fn nextgroup=rustFuncName skipwhite skipempty
-syn keyword   rustKeyword     for in if impl let move
+syn keyword   rustKeyword     for in if impl let
 syn keyword   rustKeyword     loop once proc pub
 syn keyword   rustKeyword     return super
 syn keyword   rustKeyword     unsafe virtual where while
 syn keyword   rustKeyword     use nextgroup=rustModPath skipwhite skipempty
 " FIXME: Scoped impl's name is also fallen in this category
 syn keyword   rustKeyword     mod trait struct enum type nextgroup=rustIdentifier skipwhite skipempty
-syn keyword   rustStorage     mut ref static const
+syn keyword   rustStorage     move mut ref static const
 
 syn keyword   rustInvalidBareKeyword crate
 

branches/auto/src/librustc/back/link.rs

@@ -890,9 +890,6 @@ fn link_args(cmd: &mut Command,
         cmd.arg(obj_filename.with_extension("metadata.o"));
     }
 
-    // Rust does its' own LTO
-    cmd.arg("-fno-lto");
-
     if t.options.is_like_osx {
         // The dead_strip option to the linker specifies that functions and data
         // unreachable by the entry point will be removed. This is quite useful

branches/auto/src/librustc/driver/driver.rs

@@ -568,8 +568,8 @@ pub fn phase_6_link_output(sess: &Session,
                            trans: &CrateTranslation,
                            outputs: &OutputFilenames) {
     let old_path = os::getenv("PATH").unwrap_or_else(||String::new());
-    let mut new_path = os::split_paths(old_path.as_slice());
-    new_path.extend(sess.host_filesearch().get_tools_search_paths().into_iter());
+    let mut new_path = sess.host_filesearch().get_tools_search_paths();
+    new_path.extend(os::split_paths(old_path.as_slice()).into_iter());
     os::setenv("PATH", os::join_paths(new_path.as_slice()).unwrap());
 
     time(sess.time_passes(), "linking", (), |_|

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

@@ -32,11 +32,10 @@ use middle::typeck::infer;
 use middle::{typeck, ty, def, pat_util, stability};
 use middle::const_eval::{eval_const_expr_partial, const_int, const_uint};
 use util::ppaux::{ty_to_string};
-use util::nodemap::NodeSet;
+use util::nodemap::{FnvHashMap, NodeSet};
 use lint::{Context, LintPass, LintArray};
 
 use std::cmp;
-use std::collections::HashMap;
 use std::collections::hash_map::{Occupied, Vacant};
 use std::slice;
 use std::{i8, i16, i32, i64, u8, u16, u32, u64, f32, f64};
@@ -1284,7 +1283,7 @@ impl UnusedMut {
         // collect all mutable pattern and group their NodeIDs by their Identifier to
         // avoid false warnings in match arms with multiple patterns
 
-        let mut mutables = HashMap::new();
+        let mut mutables = FnvHashMap::new();
         for p in pats.iter() {
             pat_util::pat_bindings(&cx.tcx.def_map, &**p, |mode, id, _, path1| {
                 let ident = path1.node;

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

@@ -34,8 +34,8 @@ use driver::early_error;
 use lint::{Level, LevelSource, Lint, LintId, LintArray, LintPass, LintPassObject};
 use lint::{Default, CommandLine, Node, Allow, Warn, Deny, Forbid};
 use lint::builtin;
+use util::nodemap::FnvHashMap;
 
-use std::collections::HashMap;
 use std::rc::Rc;
 use std::cell::RefCell;
 use std::tuple::Tuple2;
@@ -63,14 +63,14 @@ pub struct LintStore {
     passes: Option<Vec<LintPassObject>>,
 
     /// Lints indexed by name.
-    by_name: HashMap<String, TargetLint>,
+    by_name: FnvHashMap<String, TargetLint>,
 
     /// Current levels of each lint, and where they were set.
-    levels: HashMap<LintId, LevelSource>,
+    levels: FnvHashMap<LintId, LevelSource>,
 
     /// Map of registered lint groups to what lints they expand to. The bool
     /// is true if the lint group was added by a plugin.
-    lint_groups: HashMap<&'static str, (Vec<LintId>, bool)>,
+    lint_groups: FnvHashMap<&'static str, (Vec<LintId>, bool)>,
 }
 
 /// The targed of the `by_name` map, which accounts for renaming/deprecation.
@@ -102,9 +102,9 @@ impl LintStore {
         LintStore {
             lints: vec!(),
             passes: Some(vec!()),
-            by_name: HashMap::new(),
-            levels: HashMap::new(),
-            lint_groups: HashMap::new(),
+            by_name: FnvHashMap::new(),
+            levels: FnvHashMap::new(),
+            lint_groups: FnvHashMap::new(),
         }
     }
 
@@ -279,7 +279,8 @@ impl LintStore {
                 Some(lint_id) => self.set_level(lint_id, (level, CommandLine)),
                 None => {
                     match self.lint_groups.iter().map(|(&x, pair)| (x, pair.ref0().clone()))
-                                                 .collect::<HashMap<&'static str, Vec<LintId>>>()
+                                                 .collect::<FnvHashMap<&'static str,
+                                                                       Vec<LintId>>>()
                                                  .find_equiv(lint_name.as_slice()) {
                         Some(v) => {
                             v.iter()
@@ -317,7 +318,7 @@ pub struct Context<'a, 'tcx: 'a> {
 
     /// Level of lints for certain NodeIds, stored here because the body of
     /// the lint needs to run in trans.
-    node_levels: RefCell<HashMap<(ast::NodeId, LintId), LevelSource>>,
+    node_levels: RefCell<FnvHashMap<(ast::NodeId, LintId), LevelSource>>,
 }
 
 /// Convenience macro for calling a `LintPass` method on every pass in the context.
@@ -425,7 +426,7 @@ impl<'a, 'tcx> Context<'a, 'tcx> {
             exported_items: exported_items,
             lints: lint_store,
             level_stack: vec![],
-            node_levels: RefCell::new(HashMap::new()),
+            node_levels: RefCell::new(FnvHashMap::new()),
         }
     }
 

branches/auto/src/librustc/metadata/creader.rs

@@ -21,9 +21,9 @@ use metadata::decoder;
 use metadata::loader;
 use metadata::loader::CratePaths;
 use plugin::load::PluginMetadata;
+use util::nodemap::FnvHashMap;
 
 use std::rc::Rc;
-use std::collections::HashMap;
 use std::collections::hash_map::{Occupied, Vacant};
 use syntax::ast;
 use syntax::abi;
@@ -85,7 +85,7 @@ fn dump_crates(cstore: &CStore) {
 }
 
 fn warn_if_multiple_versions(diag: &SpanHandler, cstore: &CStore) {
-    let mut map = HashMap::new();
+    let mut map = FnvHashMap::new();
     cstore.iter_crate_data(|cnum, data| {
         match map.entry(data.name()) {
             Vacant(entry) => { entry.set(vec![cnum]); },

branches/auto/src/librustc/metadata/cstore.rs

@@ -16,11 +16,11 @@
 use back::svh::Svh;
 use metadata::decoder;
 use metadata::loader;
+use util::nodemap::{FnvHashMap, NodeMap};
 
 use std::cell::RefCell;
 use std::c_vec::CVec;
 use std::rc::Rc;
-use std::collections::HashMap;
 use syntax::ast;
 use syntax::codemap::Span;
 use syntax::parse::token::IdentInterner;
@@ -29,7 +29,7 @@ use syntax::parse::token::IdentInterner;
 // local crate numbers (as generated during this session). Each external
 // crate may refer to types in other external crates, and each has their
 // own crate numbers.
-pub type cnum_map = HashMap<ast::CrateNum, ast::CrateNum>;
+pub type cnum_map = FnvHashMap<ast::CrateNum, ast::CrateNum>;
 
 pub enum MetadataBlob {
     MetadataVec(CVec<u8>),
@@ -67,22 +67,20 @@ pub struct CrateSource {
 }
 
 pub struct CStore {
-    metas: RefCell<HashMap<ast::CrateNum, Rc<crate_metadata>>>,
-    extern_mod_crate_map: RefCell<extern_mod_crate_map>,
+    metas: RefCell<FnvHashMap<ast::CrateNum, Rc<crate_metadata>>>,
+    /// Map from NodeId's of local extern crate statements to crate numbers
+    extern_mod_crate_map: RefCell<NodeMap<ast::CrateNum>>,
     used_crate_sources: RefCell<Vec<CrateSource>>,
     used_libraries: RefCell<Vec<(String, NativeLibaryKind)>>,
     used_link_args: RefCell<Vec<String>>,
     pub intr: Rc<IdentInterner>,
 }
 
-// Map from NodeId's of local extern crate statements to crate numbers
-type extern_mod_crate_map = HashMap<ast::NodeId, ast::CrateNum>;
-
 impl CStore {
     pub fn new(intr: Rc<IdentInterner>) -> CStore {
         CStore {
-            metas: RefCell::new(HashMap::new()),
-            extern_mod_crate_map: RefCell::new(HashMap::new()),
+            metas: RefCell::new(FnvHashMap::new()),
+            extern_mod_crate_map: RefCell::new(FnvHashMap::new()),
             used_crate_sources: RefCell::new(Vec::new()),
             used_libraries: RefCell::new(Vec::new()),
             used_link_args: RefCell::new(Vec::new()),

branches/auto/src/librustc/metadata/encoder.rs

@@ -23,13 +23,12 @@ use middle::ty::{lookup_item_type};
 use middle::ty;
 use middle::stability;
 use middle;
-use util::nodemap::{NodeMap, NodeSet};
+use util::nodemap::{FnvHashMap, NodeMap, NodeSet};
 
 use serialize::Encodable;
 use std::cell::RefCell;
 use std::hash::Hash;
 use std::hash;
-use std::collections::HashMap;
 use syntax::abi;
 use syntax::ast::*;
 use syntax::ast;
@@ -2062,7 +2061,7 @@ fn encode_metadata_inner(wr: &mut SeekableMemWriter, parms: EncodeParams, krate:
         link_meta: link_meta,
         cstore: cstore,
         encode_inlined_item: RefCell::new(encode_inlined_item),
-        type_abbrevs: RefCell::new(HashMap::new()),
+        type_abbrevs: RefCell::new(FnvHashMap::new()),
         reachable: reachable,
      };
 
@@ -2167,7 +2166,7 @@ pub fn encoded_ty(tcx: &ty::ctxt, t: ty::t) -> String {
         diag: tcx.sess.diagnostic(),
         ds: def_to_string,
         tcx: tcx,
-        abbrevs: &RefCell::new(HashMap::new())
+        abbrevs: &RefCell::new(FnvHashMap::new())
     }, t);
     String::from_utf8(wr.unwrap()).unwrap()
 }

branches/auto/src/librustc/metadata/filesearch.rs

@@ -150,12 +150,8 @@ impl<'a> FileSearch<'a> {
         p.push(find_libdir(self.sysroot));
         p.push(rustlibdir());
         p.push(self.triple);
-        let mut p1 = p.clone();
-        p1.push("bin");
-        let mut p2 = p.clone();
-        p2.push("gcc");
-        p2.push("bin");
-        vec![p1, p2]
+        p.push("bin");
+        vec![p]
     }
 }
 

branches/auto/src/librustc/metadata/tyencode.rs

@@ -14,12 +14,12 @@
 #![allow(non_camel_case_types)]
 
 use std::cell::RefCell;
-use std::collections::HashMap;
 
 use middle::subst;
 use middle::subst::VecPerParamSpace;
 use middle::ty::ParamTy;
 use middle::ty;
+use util::nodemap::FnvHashMap;
 
 use syntax::abi::Abi;
 use syntax::ast;
@@ -47,7 +47,7 @@ pub struct ty_abbrev {
     s: String
 }
 
-pub type abbrev_map = RefCell<HashMap<ty::t, ty_abbrev>>;
+pub type abbrev_map = RefCell<FnvHashMap<ty::t, ty_abbrev>>;
 
 pub fn enc_ty(w: &mut SeekableMemWriter, cx: &ctxt, t: ty::t) {
     match cx.abbrevs.borrow_mut().get(&t) {

branches/auto/src/librustc/middle/astencode.rs

@@ -1161,7 +1161,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext,
         })
     }
 
-    for &ty in tcx.node_types.borrow().get(&(id as uint)).iter() {
+    for &ty in tcx.node_types.borrow().get(&id).iter() {
         rbml_w.tag(c::tag_table_node_type, |rbml_w| {
             rbml_w.id(id);
             rbml_w.tag(c::tag_table_val, |rbml_w| {
@@ -1825,7 +1825,7 @@ fn decode_side_tables(dcx: &DecodeContext,
                         let ty = val_dsr.read_ty(dcx);
                         debug!("inserting ty for node {}: {}",
                                id, ty_to_string(dcx.tcx, ty));
-                        dcx.tcx.node_types.borrow_mut().insert(id as uint, ty);
+                        dcx.tcx.node_types.borrow_mut().insert(id, ty);
                     }
                     c::tag_table_item_subst => {
                         let item_substs = ty::ItemSubsts {