---

yaml
---
r: 159069
b: refs/heads/snap-stage3
c: 27774e8
h: refs/heads/master
i:
  159067: 54fa309
v: v3

Author: swgillespie

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 40fb87d40f681f5356af42175fc7b85da387f037
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 8f8753878644b0bfb38d24781edb9ef2028730f2
+refs/heads/snap-stage3: 27774e8e24fe66b6463ca1916eeea1626c663e77
 refs/heads/try: f58aad6dce273570fb130b4df008ef9acd5a5be2
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/src/etc/emacs/rust-mode.el

@@ -176,7 +176,7 @@
     "false" "fn" "for"
     "if" "impl" "in"
     "let" "loop"
-    "match" "mod" "mut"
+    "match" "mod" "move" "mut"
     "priv" "proc" "pub"
     "ref" "return"
     "self" "static" "struct" "super"

branches/snap-stage3/src/etc/kate/rust.xml

@@ -34,6 +34,7 @@
 		<item> loop </item>
 		<item> match </item>
 		<item> mod </item>
+		<item> move </item>
 		<item> mut </item>
 		<item> priv </item>
 		<item> pub </item>

branches/snap-stage3/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,48 +42,11 @@ def make_win_dist(dist_root, target_triple):
     else:
         rustc_dlls.append("libgcc_s_seh-1.dll")
 
-    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",
-                    ]
+    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"]
 
     # Find mingw artifacts we want to bundle
     target_tools = find_files(target_tools, bin_path)
@@ -96,14 +59,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, "bin")
+    target_bin_dir = os.path.join(dist_root, "bin", "rustlib", target_triple, "gcc", "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, "lib")
+    target_lib_dir = os.path.join(dist_root, "bin", "rustlib", target_triple, "gcc", "lib")
     if not os.path.exists(target_lib_dir):
         os.makedirs(target_lib_dir)
     for src in target_libs:

branches/snap-stage3/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
+syn keyword   rustKeyword     for in if impl let move
 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     move mut ref static const
+syn keyword   rustStorage     mut ref static const
 
 syn keyword   rustInvalidBareKeyword crate
 

branches/snap-stage3/src/librustc/back/link.rs

@@ -890,6 +890,9 @@ 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/snap-stage3/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 = sess.host_filesearch().get_tools_search_paths();
-    new_path.extend(os::split_paths(old_path.as_slice()).into_iter());
+    let mut new_path = os::split_paths(old_path.as_slice());
+    new_path.extend(sess.host_filesearch().get_tools_search_paths().into_iter());
     os::setenv("PATH", os::join_paths(new_path.as_slice()).unwrap());
 
     time(sess.time_passes(), "linking", (), |_|

branches/snap-stage3/src/librustc/lint/builtin.rs

@@ -32,10 +32,11 @@ 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::{FnvHashMap, NodeSet};
+use util::nodemap::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};
@@ -1283,7 +1284,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 = FnvHashMap::new();
+        let mut mutables = HashMap::new();
         for p in pats.iter() {
             pat_util::pat_bindings(&cx.tcx.def_map, &**p, |mode, id, _, path1| {
                 let ident = path1.node;

branches/snap-stage3/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: FnvHashMap<String, TargetLint>,
+    by_name: HashMap<String, TargetLint>,
 
     /// Current levels of each lint, and where they were set.
-    levels: FnvHashMap<LintId, LevelSource>,
+    levels: HashMap<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: FnvHashMap<&'static str, (Vec<LintId>, bool)>,
+    lint_groups: HashMap<&'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: FnvHashMap::new(),
-            levels: FnvHashMap::new(),
-            lint_groups: FnvHashMap::new(),
+            by_name: HashMap::new(),
+            levels: HashMap::new(),
+            lint_groups: HashMap::new(),
         }
     }
 
@@ -279,8 +279,7 @@ 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::<FnvHashMap<&'static str,
-                                                                       Vec<LintId>>>()
+                                                 .collect::<HashMap<&'static str, Vec<LintId>>>()
                                                  .find_equiv(lint_name.as_slice()) {
                         Some(v) => {
                             v.iter()
@@ -318,7 +317,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<FnvHashMap<(ast::NodeId, LintId), LevelSource>>,
+    node_levels: RefCell<HashMap<(ast::NodeId, LintId), LevelSource>>,
 }
 
 /// Convenience macro for calling a `LintPass` method on every pass in the context.
@@ -426,7 +425,7 @@ impl<'a, 'tcx> Context<'a, 'tcx> {
             exported_items: exported_items,
             lints: lint_store,
             level_stack: vec![],
-            node_levels: RefCell::new(FnvHashMap::new()),
+            node_levels: RefCell::new(HashMap::new()),
         }
     }
 

branches/snap-stage3/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 = FnvHashMap::new();
+    let mut map = HashMap::new();
     cstore.iter_crate_data(|cnum, data| {
         match map.entry(data.name()) {
             Vacant(entry) => { entry.set(vec![cnum]); },

branches/snap-stage3/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 = FnvHashMap<ast::CrateNum, ast::CrateNum>;
+pub type cnum_map = HashMap<ast::CrateNum, ast::CrateNum>;
 
 pub enum MetadataBlob {
     MetadataVec(CVec<u8>),
@@ -67,20 +67,22 @@ pub struct CrateSource {
 }
 
 pub struct CStore {
-    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>>,
+    metas: RefCell<HashMap<ast::CrateNum, Rc<crate_metadata>>>,
+    extern_mod_crate_map: RefCell<extern_mod_crate_map>,
     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(FnvHashMap::new()),
-            extern_mod_crate_map: RefCell::new(FnvHashMap::new()),
+            metas: RefCell::new(HashMap::new()),
+            extern_mod_crate_map: RefCell::new(HashMap::new()),
             used_crate_sources: RefCell::new(Vec::new()),
             used_libraries: RefCell::new(Vec::new()),
             used_link_args: RefCell::new(Vec::new()),

branches/snap-stage3/src/librustc/metadata/encoder.rs

@@ -23,12 +23,13 @@ use middle::ty::{lookup_item_type};
 use middle::ty;
 use middle::stability;
 use middle;
-use util::nodemap::{FnvHashMap, NodeMap, NodeSet};
+use util::nodemap::{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;
@@ -2061,7 +2062,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(FnvHashMap::new()),
+        type_abbrevs: RefCell::new(HashMap::new()),
         reachable: reachable,
      };
 
@@ -2166,7 +2167,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(FnvHashMap::new())
+        abbrevs: &RefCell::new(HashMap::new())
     }, t);
     String::from_utf8(wr.unwrap()).unwrap()
 }

branches/snap-stage3/src/librustc/metadata/filesearch.rs

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

branches/snap-stage3/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<FnvHashMap<ty::t, ty_abbrev>>;
+pub type abbrev_map = RefCell<HashMap<ty::t, ty_abbrev>>;
 
 pub fn enc_ty(w: &mut SeekableMemWriter, cx: &ctxt, t: ty::t) {
     match cx.abbrevs.borrow_mut().get(&t) {

branches/snap-stage3/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).iter() {
+    for &ty in tcx.node_types.borrow().get(&(id as uint)).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, ty);
+                        dcx.tcx.node_types.borrow_mut().insert(id as uint, ty);
                     }
                     c::tag_table_item_subst => {
                         let item_substs = ty::ItemSubsts {