---

yaml
---
r: 73647
b: refs/heads/dist-snap
c: 6e075b6
h: refs/heads/master
i:
  73645: a52cdcf
  73643: ed2dc61
  73639: 9e189c6
  73631: bba81cc
v: v3

Author: James Miller

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: b50030718cf28f2a5a81857a26b57442734fe854
-refs/heads/dist-snap: 42466949c24c07e6d5e13a87054d066a72ea0d99
+refs/heads/dist-snap: 6e075b6bb6c15e8fa358e08670687e3c94f4565b
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/librustc/back/passes.rs

@@ -70,9 +70,12 @@ pub fn create_standard_passes(level:OptLevel) -> ~[~str] {
 
     passes.push(~"targetlibinfo");
 
-    passes.push(~"tbaa");
+    passes.push(~"scev-aa");
     passes.push(~"basicaa");
 
+    passes.push(~"instcombine");
+    passes.push(~"simplifycfg");
+    passes.push(~"scalarrepl-ssa");
     passes.push(~"early-cse");
 
     passes.push(~"globalopt");
@@ -83,10 +86,6 @@ pub fn create_standard_passes(level:OptLevel) -> ~[~str] {
 
     passes.push(~"prune-eh");
 
-    if level == Aggressive {
-        passes.push(~"mergefunc");
-    }
-
     passes.push(~"inline");
 
     passes.push(~"functionattrs");
@@ -95,6 +94,7 @@ pub fn create_standard_passes(level:OptLevel) -> ~[~str] {
         passes.push(~"argpromotion");
     }
 
+    passes.push(~"scalarrepl-ssa");
     passes.push(~"early-cse");
     passes.push(~"simplify-libcalls");
     passes.push(~"jump-threading");
@@ -134,11 +134,6 @@ pub fn create_standard_passes(level:OptLevel) -> ~[~str] {
     passes.push(~"correlated-propagation");
     passes.push(~"dse");
 
-    passes.push(~"instcombine");
-    passes.push(~"early-cse");
-
-    passes.push(~"loop-unroll");
-
     passes.push(~"adce");
     passes.push(~"simplifycfg");
     passes.push(~"instsimplify");

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

@@ -374,90 +374,50 @@ fn encode_path(ecx: @EncodeContext,
 fn encode_reexported_static_method(ecx: @EncodeContext,
                                    ebml_w: &mut writer::Encoder,
                                    exp: &middle::resolve::Export2,
-                                   method_def_id: def_id,
-                                   method_ident: ident) {
-    debug!("(encode reexported static method) %s::%s",
-            *exp.name, *ecx.tcx.sess.str_of(method_ident));
+                                   m: @ty::Method) {
+    debug!("(encode static trait method) reexport '%s::%s'",
+            *exp.name, *ecx.tcx.sess.str_of(m.ident));
     ebml_w.start_tag(tag_items_data_item_reexport);
     ebml_w.start_tag(tag_items_data_item_reexport_def_id);
-    ebml_w.wr_str(def_to_str(method_def_id));
+    ebml_w.wr_str(def_to_str(m.def_id));
     ebml_w.end_tag();
     ebml_w.start_tag(tag_items_data_item_reexport_name);
-    ebml_w.wr_str(*exp.name + "::" + *ecx.tcx.sess.str_of(method_ident));
+    ebml_w.wr_str(*exp.name + "::" + *ecx.tcx.sess.str_of(m.ident));
     ebml_w.end_tag();
     ebml_w.end_tag();
 }
 
-fn encode_reexported_static_base_methods(ecx: @EncodeContext,
-                                         ebml_w: &mut writer::Encoder,
-                                         exp: &middle::resolve::Export2)
-                                         -> bool {
-    match ecx.tcx.base_impls.find(&exp.def_id) {
-        Some(implementations) => {
-            for implementations.each |&base_impl| {
-                for base_impl.methods.each |&m| {
-                    if m.explicit_self == ast::sty_static {
-                        encode_reexported_static_method(ecx, ebml_w, exp,
-                                                        m.did, m.ident);
-                    }
-                }
-            }
-
-            true
-        }
-        None => { false }
-    }
-}
-
-fn encode_reexported_static_trait_methods(ecx: @EncodeContext,
-                                          ebml_w: &mut writer::Encoder,
-                                          exp: &middle::resolve::Export2)
-                                          -> bool {
-    match ecx.tcx.trait_methods_cache.find(&exp.def_id) {
-        Some(methods) => {
-            for methods.each |&m| {
-                if m.explicit_self == ast::sty_static {
-                    encode_reexported_static_method(ecx, ebml_w, exp,
-                                                    m.def_id, m.ident);
-                }
-            }
-
-            true
-        }
-        None => { false }
-    }
-}
-
 fn encode_reexported_static_methods(ecx: @EncodeContext,
                                     ebml_w: &mut writer::Encoder,
                                     mod_path: &[ast_map::path_elt],
                                     exp: &middle::resolve::Export2) {
-    match ecx.tcx.items.find(&exp.def_id.node) {
-        Some(&ast_map::node_item(item, path)) => {
-            let original_name = ecx.tcx.sess.str_of(item.ident);
-
-            //
-            // We don't need to reexport static methods on items
-            // declared in the same module as our `pub use ...` since
-            // that's done when we encode the item itself.
-            //
-            // The only exception is when the reexport *changes* the
-            // name e.g. `pub use Foo = self::Bar` -- we have
-            // encoded metadata for static methods relative to Bar,
-            // but not yet for Foo.
-            //
-            if mod_path != *path || *exp.name != *original_name {
-                if !encode_reexported_static_base_methods(ecx, ebml_w, exp) {
-                    if encode_reexported_static_trait_methods(ecx, ebml_w, exp) {
-                        debug!(fmt!("(encode reexported static methods) %s \
-                                    [trait]",
-                                    *original_name));
+    match ecx.tcx.trait_methods_cache.find(&exp.def_id) {
+        Some(methods) => {
+            match ecx.tcx.items.find(&exp.def_id.node) {
+                Some(&ast_map::node_item(item, path)) => {
+                    let original_name = ecx.tcx.sess.str_of(item.ident);
+
+                    //
+                    // We don't need to reexport static methods on traits
+                    // declared in the same module as our `pub use ...` since
+                    // that's done when we encode the trait item.
+                    //
+                    // The only exception is when the reexport *changes* the
+                    // name e.g. `pub use Foo = self::Bar` -- we have
+                    // encoded metadata for static methods relative to Bar,
+                    // but not yet for Foo.
+                    //
+                    if mod_path != *path || *exp.name != *original_name {
+                        for methods.each |&m| {
+                            if m.explicit_self == ast::sty_static {
+                                encode_reexported_static_method(ecx,
+                                                                ebml_w,
+                                                                exp, m);
+                            }
+                        }
                     }
                 }
-                else {
-                    debug!(fmt!("(encode reexported static methods) %s [base]",
-                                *original_name));
-                }
+                _ => {}
             }
         }
         _ => {}

branches/dist-snap/src/librustc/middle/lint.rs

@@ -96,7 +96,6 @@ pub enum lint {
     unnecessary_allocation,
 
     missing_doc,
-    unreachable_code,
 }
 
 pub fn level_to_str(lv: level) -> &'static str {
@@ -274,13 +273,6 @@ static lint_table: &'static [(&'static str, LintSpec)] = &[
         desc: "detects missing documentation for public members",
         default: allow
     }),
-
-    ("unreachable_code",
-     LintSpec {
-        lint: unreachable_code,
-        desc: "detects unreachable code",
-        default: warn
-    }),
 ];
 
 /*

branches/dist-snap/src/librustc/middle/ty.rs

@@ -306,9 +306,6 @@ struct ctxt_ {
     // Maps a trait onto a mapping from self-ty to impl
     trait_impls: @mut HashMap<ast::def_id, @mut HashMap<t, @Impl>>,
 
-    // Maps a base type to its impl
-    base_impls: @mut HashMap<ast::def_id, @mut ~[@Impl]>,
-
     // Set of used unsafe nodes (functions or blocks). Unsafe nodes not
     // present in this set can be warned about.
     used_unsafe: @mut HashSet<ast::node_id>,
@@ -974,7 +971,6 @@ pub fn mk_ctxt(s: session::Session,
         destructor_for_type: @mut HashMap::new(),
         destructors: @mut HashSet::new(),
         trait_impls: @mut HashMap::new(),
-        base_impls:  @mut HashMap::new(),
         used_unsafe: @mut HashSet::new(),
         used_mut_nodes: @mut HashSet::new(),
      }
@@ -3703,21 +3699,6 @@ pub fn trait_method(cx: ctxt, trait_did: ast::def_id, idx: uint) -> @Method {
     ty::method(cx, method_def_id)
 }
 
-
-pub fn add_base_impl(cx: ctxt, base_def_id: def_id, implementation: @Impl) {
-    let implementations;
-    match cx.base_impls.find(&base_def_id) {
-        None => {
-            implementations = @mut ~[];
-            cx.base_impls.insert(base_def_id, implementations);
-        }
-        Some(&existing) => {
-            implementations = existing;
-        }
-    }
-    implementations.push(implementation);
-}
-
 pub fn trait_methods(cx: ctxt, trait_did: ast::def_id) -> @~[@Method] {
     match cx.trait_methods_cache.find(&trait_did) {
         Some(&methods) => methods,

branches/dist-snap/src/librustc/middle/typeck/check/mod.rs

@@ -81,7 +81,6 @@ use core::prelude::*;
 use middle::const_eval;
 use middle::pat_util::pat_id_map;
 use middle::pat_util;
-use middle::lint::unreachable_code;
 use middle::ty::{FnSig, VariantInfo_};
 use middle::ty::{ty_param_bounds_and_ty, ty_param_substs_and_ty};
 use middle::ty::{substs, param_ty};
@@ -2938,8 +2937,7 @@ pub fn check_block_with_expected(fcx: @mut FnCtxt,
         let mut any_err = false;
         for blk.node.stmts.each |s| {
             check_stmt(fcx, *s);
-            let s_id = ast_util::stmt_id(*s);
-            let s_ty = fcx.node_ty(s_id);
+            let s_ty = fcx.node_ty(ast_util::stmt_id(*s));
             if last_was_bot && !warned && match s.node {
                   ast::stmt_decl(@codemap::spanned { node: ast::decl_local(_),
                                                  _}, _) |
@@ -2948,8 +2946,7 @@ pub fn check_block_with_expected(fcx: @mut FnCtxt,
                   }
                   _ => false
                 } {
-                fcx.ccx.tcx.sess.add_lint(unreachable_code, s_id, s.span,
-                                          ~"unreachable statement");
+                fcx.ccx.tcx.sess.span_warn(s.span, "unreachable statement");
                 warned = true;
             }
             if ty::type_is_bot(s_ty) {

branches/dist-snap/src/librustc/middle/typeck/coherence.rs

@@ -146,7 +146,7 @@ pub fn get_base_type_def_id(inference_context: @mut InferCtxt,
                 }
                 _ => {
                     fail!("get_base_type() returned a type that wasn't an \
-                           enum, struct, or trait");
+                           enum, class, or trait");
                 }
             }
         }
@@ -312,7 +312,6 @@ pub impl CoherenceChecker {
                             implementation = existing_implementation;
                         }
                     }
-
                     self.add_inherent_method(base_type_def_id,
                                              implementation);
                 }
@@ -433,8 +432,6 @@ pub impl CoherenceChecker {
         }
 
         implementation_list.push(implementation);
-
-        ty::add_base_impl(self.crate_context.tcx, base_def_id, implementation);
     }
 
     fn add_trait_method(&self, trait_id: def_id, implementation: @Impl) {

branches/dist-snap/src/libstd/hashmap.rs

@@ -72,12 +72,11 @@ pub fn linear_map_with_capacity<K:Eq + Hash,V>(
 fn linear_map_with_capacity_and_keys<K:Eq + Hash,V>(
     k0: u64, k1: u64,
     initial_capacity: uint) -> HashMap<K, V> {
-    let cap = uint::max(INITIAL_CAPACITY, initial_capacity);
     HashMap {
         k0: k0, k1: k1,
-        resize_at: resize_at(cap),
+        resize_at: resize_at(initial_capacity),
         size: 0,
-        buckets: vec::from_fn(cap, |_| None)
+        buckets: vec::from_fn(initial_capacity, |_| None)
     }
 }
 
@@ -481,8 +480,7 @@ pub impl<K: Hash + Eq, V> HashMap<K, V> {
     }
 
     fn consume(&mut self, f: &fn(K, V)) {
-        let buckets = replace(&mut self.buckets,
-                              vec::from_fn(INITIAL_CAPACITY, |_| None));
+        let buckets = replace(&mut self.buckets, ~[]);
         self.size = 0;
 
         do vec::consume(buckets) |_, bucket| {
@@ -666,12 +664,6 @@ mod test_map {
     use super::*;
     use uint;
 
-    #[test]
-    fn test_create_capacity_zero() {
-        let mut m = HashMap::with_capacity(0);
-        assert!(m.insert(1, 1));
-    }
-
     #[test]
     fn test_insert() {
         let mut m = HashMap::new();
@@ -779,14 +771,6 @@ mod test_map {
         assert_eq!(m2.get(&2), &3);
     }
 
-    #[test]
-    fn test_consume_still_usable() {
-        let mut m = HashMap::new();
-        assert!(m.insert(1, 2));
-        do m.consume |_, _| {}
-        assert!(m.insert(1, 2));
-    }
-
     #[test]
     fn test_iterate() {
         let mut m = linear_map_with_capacity(4);

branches/dist-snap/src/libstd/prelude.rs

@@ -45,7 +45,7 @@ pub use path::PosixPath;
 pub use path::WindowsPath;
 pub use ptr::Ptr;
 pub use ascii::{Ascii, AsciiCast, OwnedAsciiCast, AsciiStr};
-pub use str::{StrSlice, OwnedStr, StrUtil};
+pub use str::{StrSlice, OwnedStr};
 pub use from_str::{FromStr};
 pub use to_bytes::IterBytes;
 pub use to_str::{ToStr, ToStrConsume};