---

yaml
---
r: 47093
b: refs/heads/try
c: 9ba2e65
h: refs/heads/master
i:
  47091: 8cbc596
v: v3

Author: bors

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 3bbcac322669cff3abde5be937cc4ec3860f3985
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d9689399d091c3265f00434a69c551a61c28dc
-refs/heads/try: aa284de1fc246b55fb53783ded3e9786e04b03d0
+refs/heads/try: 9ba2e65fd6892d2200b517d11e95870e4b2ece12
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libcore/to_str.rs

@@ -43,8 +43,6 @@ impl ToStr for @str {
     pure fn to_str(&self) -> ~str { ::str::from_slice(*self) }
 }
 
-// FIXME #4898: impl for one-tuples
-
 impl<A: ToStr, B: ToStr> ToStr for (A, B) {
     #[inline(always)]
     pure fn to_str(&self) -> ~str {

branches/try/src/libcore/tuple.rs

@@ -111,8 +111,6 @@ impl<A: Copy, B: Copy> ExtendedTupleOps<A,B> for (~[A], ~[B]) {
     }
 }
 
-// FIXME #4898: impl for one-tuples
-
 #[cfg(notest)]
 impl<A: Eq, B: Eq> Eq for (A, B) {
     #[inline(always)]

branches/try/src/libcore/vec.rs

@@ -1865,6 +1865,7 @@ pub trait OwnedVector<T> {
     fn consume(self, f: fn(uint, v: T));
     fn filter(self, f: fn(t: &T) -> bool) -> ~[T];
     fn partition(self, f: pure fn(&T) -> bool) -> (~[T], ~[T]);
+    fn grow_fn(&mut self, n: uint, op: iter::InitOp<T>);
 }
 
 impl<T> OwnedVector<T> for ~[T] {
@@ -1936,6 +1937,11 @@ impl<T> OwnedVector<T> for ~[T] {
     fn partition(self, f: fn(&T) -> bool) -> (~[T], ~[T]) {
         partition(self, f)
     }
+
+    #[inline]
+    fn grow_fn(&mut self, n: uint, op: iter::InitOp<T>) {
+        grow_fn(self, n, op);
+    }
 }
 
 impl<T> Mutable for ~[T] {
@@ -1946,7 +1952,6 @@ impl<T> Mutable for ~[T] {
 pub trait OwnedCopyableVector<T: Copy> {
     fn push_all(&mut self, rhs: &[const T]);
     fn grow(&mut self, n: uint, initval: &T);
-    fn grow_fn(&mut self, n: uint, op: iter::InitOp<T>);
     fn grow_set(&mut self, index: uint, initval: &T, val: T);
 }
 
@@ -1961,11 +1966,6 @@ impl<T: Copy> OwnedCopyableVector<T> for ~[T] {
         grow(self, n, initval);
     }
 
-    #[inline]
-    fn grow_fn(&mut self, n: uint, op: iter::InitOp<T>) {
-        grow_fn(self, n, op);
-    }
-
     #[inline]
     fn grow_set(&mut self, index: uint, initval: &T, val: T) {
         grow_set(self, index, initval, val);

branches/try/src/librustc/front/core_inject.rs

@@ -45,7 +45,8 @@ fn inject_libcore_ref(sess: Session,
         fold_crate: |crate, span, fld| {
             let n1 = sess.next_node_id();
             let vi1 = @ast::view_item {
-                node: ast::view_item_use(sess.ident_of(~"core"), ~[], n1),
+                node: ast::view_item_extern_mod(
+                        sess.ident_of(~"core"), ~[], n1),
                 attrs: ~[
                     spanned(ast::attribute_ {
                         style: ast::attr_inner,
@@ -86,7 +87,7 @@ fn inject_libcore_ref(sess: Session,
             };
 
             let vp = @spanned(ast::view_path_glob(prelude_path, n2));
-            let vi2 = @ast::view_item { node: ast::view_item_import(~[vp]),
+            let vi2 = @ast::view_item { node: ast::view_item_use(~[vp]),
                                         attrs: ~[],
                                         vis: ast::private,
                                         span: dummy_sp() };

branches/try/src/librustc/front/test.rs

@@ -266,13 +266,13 @@ fn mk_std(cx: &TestCtxt) -> @ast::view_item {
     let mi = nospan(mi);
     let id_std = cx.sess.ident_of(~"std");
     let vi = if is_std(cx) {
-        ast::view_item_import(
+        ast::view_item_use(
             ~[@nospan(ast::view_path_simple(id_std,
                                             path_node(~[id_std]),
                                             ast::type_value_ns,
                                             cx.sess.next_node_id()))])
     } else {
-        ast::view_item_use(id_std, ~[@mi],
+        ast::view_item_extern_mod(id_std, ~[@mi],
                            cx.sess.next_node_id())
     };
     let vi = ast::view_item {

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

@@ -55,6 +55,7 @@ pub fn read_crates(diag: span_handler,
             visit_view_item: |a| visit_view_item(e, a),
             visit_item: |a| visit_item(e, a),
             .. *visit::default_simple_visitor()});
+    visit_crate(e, crate);
     visit::visit_crate(crate, (), v);
     dump_crates(e.crate_cache);
     warn_if_multiple_versions(e, diag, e.crate_cache);
@@ -125,12 +126,27 @@ struct Env {
     intr: @ident_interner
 }
 
+fn visit_crate(e: @mut Env, c: ast::crate) {
+    let cstore = e.cstore;
+    let link_args = attr::find_attrs_by_name(c.node.attrs, "link_args");
+
+    for link_args.each |a| {
+        match attr::get_meta_item_value_str(attr::attr_meta(*a)) {
+          Some(ref linkarg) => {
+            cstore::add_used_link_args(cstore, (/*bad*/copy *linkarg));
+          }
+          None => {/* fallthrough */ }
+        }
+    }
+}
+
 fn visit_view_item(e: @mut Env, i: @ast::view_item) {
     match /*bad*/copy i.node {
-      ast::view_item_use(ident, meta_items, id) => {
-        debug!("resolving use stmt. ident: %?, meta: %?", ident, meta_items);
+      ast::view_item_extern_mod(ident, meta_items, id) => {
+        debug!("resolving extern mod stmt. ident: %?, meta: %?",
+               ident, meta_items);
         let cnum = resolve_crate(e, ident, meta_items, ~"", i.span);
-        cstore::add_use_stmt_cnum(e.cstore, id, cnum);
+        cstore::add_extern_mod_stmt_cnum(e.cstore, id, cnum);
       }
       _ => ()
     }
@@ -181,7 +197,7 @@ fn visit_item(e: @mut Env, i: @ast::item) {
         for link_args.each |a| {
             match attr::get_meta_item_value_str(attr::attr_meta(*a)) {
               Some(ref linkarg) => {
-                cstore::add_used_link_args(cstore, (/*bad*/copy *linkarg));
+                cstore::add_used_link_args(cstore, *linkarg);
               }
               None => {/* fallthrough */ }
             }

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

@@ -40,22 +40,22 @@ pub type crate_metadata = @{name: ~str,
 
 pub struct CStore {
     priv metas: oldmap::HashMap<ast::crate_num, crate_metadata>,
-    priv use_crate_map: use_crate_map,
+    priv extern_mod_crate_map: extern_mod_crate_map,
     priv used_crate_files: ~[Path],
     priv used_libraries: ~[~str],
     priv used_link_args: ~[~str],
     intr: @ident_interner
 }
 
-// Map from node_id's of local use statements to crate numbers
-type use_crate_map = oldmap::HashMap<ast::node_id, ast::crate_num>;
+// Map from node_id's of local extern mod statements to crate numbers
+type extern_mod_crate_map = oldmap::HashMap<ast::node_id, ast::crate_num>;
 
 pub fn mk_cstore(intr: @ident_interner) -> CStore {
     let meta_cache = oldmap::HashMap();
     let crate_map = oldmap::HashMap();
     return CStore {
         metas: meta_cache,
-        use_crate_map: crate_map,
+        extern_mod_crate_map: crate_map,
         used_crate_files: ~[],
         used_libraries: ~[],
         used_link_args: ~[],
@@ -119,26 +119,26 @@ pub fn get_used_libraries(cstore: @mut CStore) -> ~[~str] {
     return /*bad*/copy cstore.used_libraries;
 }
 
-pub fn add_used_link_args(cstore: @mut CStore, args: ~str) {
+pub fn add_used_link_args(cstore: @mut CStore, args: &str) {
     cstore.used_link_args.push_all(str::split_char(args, ' '));
 }
 
 pub fn get_used_link_args(cstore: @mut CStore) -> ~[~str] {
     return /*bad*/copy cstore.used_link_args;
 }
 
-pub fn add_use_stmt_cnum(cstore: @mut CStore,
-                         use_id: ast::node_id,
-                         cnum: ast::crate_num) {
-    let use_crate_map = cstore.use_crate_map;
-    use_crate_map.insert(use_id, cnum);
+pub fn add_extern_mod_stmt_cnum(cstore: @mut CStore,
+                                emod_id: ast::node_id,
+                                cnum: ast::crate_num) {
+    let extern_mod_crate_map = cstore.extern_mod_crate_map;
+    extern_mod_crate_map.insert(emod_id, cnum);
 }
 
-pub fn find_use_stmt_cnum(cstore: @mut CStore,
-                          use_id: ast::node_id)
+pub fn find_extern_mod_stmt_cnum(cstore: @mut CStore,
+                                 emod_id: ast::node_id)
                        -> Option<ast::crate_num> {
-    let use_crate_map = cstore.use_crate_map;
-    use_crate_map.find(&use_id)
+    let extern_mod_crate_map = cstore.extern_mod_crate_map;
+    extern_mod_crate_map.find(&emod_id)
 }
 
 // returns hashes of crates directly used by this crate. Hashes are
@@ -147,8 +147,8 @@ pub fn get_dep_hashes(cstore: @mut CStore) -> ~[~str] {
     type crate_hash = {name: ~str, hash: ~str};
     let mut result = ~[];
 
-    let use_crate_map = cstore.use_crate_map;
-    for use_crate_map.each_value |&cnum| {
+    let extern_mod_crate_map = cstore.extern_mod_crate_map;
+    for extern_mod_crate_map.each_value |&cnum| {
         let cdata = cstore::get_crate_data(cstore, cnum);
         let hash = decoder::get_crate_hash(cdata.data);
         debug!("Add hash[%s]: %s", cdata.name, hash);

branches/try/src/librustc/middle/resolve.rs

@@ -15,7 +15,7 @@ use driver::session::Session;
 use metadata::csearch::{each_path, get_method_names_if_trait};
 use metadata::csearch::{get_static_methods_if_impl, get_struct_fields};
 use metadata::csearch::{get_type_name_if_impl};
-use metadata::cstore::find_use_stmt_cnum;
+use metadata::cstore::find_extern_mod_stmt_cnum;
 use metadata::decoder::{def_like, dl_def, dl_field, dl_impl};
 use middle::lang_items::LanguageItems;
 use middle::lint::{deny, allow, forbid, level, unused_imports, warn};
@@ -55,7 +55,7 @@ use syntax::ast::{ty_bool, ty_char, ty_f, ty_f32, ty_f64, ty_float, ty_i};
 use syntax::ast::{ty_i16, ty_i32, ty_i64, ty_i8, ty_int, ty_param, ty_path};
 use syntax::ast::{ty_str, ty_u, ty_u16, ty_u32, ty_u64, ty_u8, ty_uint};
 use syntax::ast::{type_value_ns, ty_param_bound, unnamed_field};
-use syntax::ast::{variant, view_item, view_item_import};
+use syntax::ast::{variant, view_item, view_item_extern_mod};
 use syntax::ast::{view_item_use, view_path_glob, view_path_list};
 use syntax::ast::{view_path_simple, visibility, anonymous, named, not};
 use syntax::ast::{unsafe_fn};
@@ -1388,7 +1388,7 @@ pub impl Resolver {
                                          &&_visitor: vt<ReducedGraphParent>) {
         let privacy = visibility_to_privacy(view_item.vis);
         match /*bad*/copy view_item.node {
-            view_item_import(view_paths) => {
+            view_item_use(view_paths) => {
                 for view_paths.each |view_path| {
                     // Extract and intern the module part of the path. For
                     // globs and lists, the path is found directly in the AST;
@@ -1462,8 +1462,9 @@ pub impl Resolver {
                 }
             }
 
-            view_item_use(name, _, node_id) => {
-                match find_use_stmt_cnum(self.session.cstore, node_id) {
+            view_item_extern_mod(name, _, node_id) => {
+                match find_extern_mod_stmt_cnum(self.session.cstore,
+                                                node_id) {
                     Some(crate_id) => {
                         let (child_name_bindings, new_parent) =
                             self.add_child(name, parent, ForbidDuplicateTypes,

branches/try/src/librustc/middle/trans/type_of.rs

@@ -328,11 +328,20 @@ pub fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef {
 pub fn enum_body_types(cx: @crate_ctxt, did: ast::def_id, t: ty::t)
                     -> ~[TypeRef] {
     let univar = ty::enum_is_univariant(cx.tcx, did);
-    let size = machine::static_size_of_enum(cx, t);
     if !univar {
+        let size = machine::static_size_of_enum(cx, t);
         ~[T_enum_discrim(cx), T_array(T_i8(), size)]
-    } else {
-        ~[T_array(T_i8(), size)]
+    }
+    else {
+        // Use the actual fields, so we get the alignment right.
+        match ty::get(t).sty {
+            ty::ty_enum(_, ref substs) => {
+                do ty::enum_variants(cx.tcx, did)[0].args.map |&field_ty| {
+                    sizing_type_of(cx, ty::subst(cx.tcx, substs, field_ty))
+                }
+            }
+            _ => cx.sess.bug(~"enum is not an enum")
+        }
     }
 }
 

branches/try/src/libstd/deque.rs

@@ -100,7 +100,7 @@ fn grow<T>(nelts: uint, lo: uint, elts: &mut [Option<T>]) -> ~[Option<T>] {
     assert nelts == elts.len();
     let mut rv = ~[];
 
-    do vec::grow_fn(&mut rv, nelts + 1) |i| {
+    do rv.grow_fn(nelts + 1) |i| {
         let mut element = None;
         element <-> elts[(lo + i) % nelts];
         element

branches/try/src/libsyntax/ast.rs

@@ -1121,8 +1121,8 @@ pub struct view_item {
 #[auto_decode]
 #[deriving_eq]
 pub enum view_item_ {
-    view_item_use(ident, ~[@meta_item], node_id),
-    view_item_import(~[@view_path]),
+    view_item_extern_mod(ident, ~[@meta_item], node_id),
+    view_item_use(~[@view_path]),
 }
 
 // Meta-data associated with an item

branches/try/src/libsyntax/ast_util.rs

@@ -395,8 +395,8 @@ pub fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
 
         visit_view_item: fn@(vi: @view_item) {
             match vi.node {
-              view_item_use(_, _, id) => vfn(id),
-              view_item_import(vps) => {
+              view_item_extern_mod(_, _, id) => vfn(id),
+              view_item_use(vps) => {
                   for vec::each(vps) |vp| {
                       match vp.node {
                           view_path_simple(_, _, _, id) => vfn(id),

branches/try/src/libsyntax/ext/build.rs

@@ -192,7 +192,7 @@ pub fn mk_glob_use(cx: ext_ctxt,
         node: ast::view_path_glob(mk_raw_path(sp, path), cx.next_id()),
         span: sp,
     };
-    @ast::view_item { node: ast::view_item_import(~[glob]),
+    @ast::view_item { node: ast::view_item_use(~[glob]),
                       attrs: ~[],
                       vis: ast::private,
                       span: sp }