Merge remote-tracking branch 'rust-lang/master'

Conflicts:
	mk/tests.mk
	src/liballoc/arc.rs
	src/liballoc/boxed.rs
	src/liballoc/rc.rs
	src/libcollections/bit.rs
	src/libcollections/btree/map.rs
	src/libcollections/btree/set.rs
	src/libcollections/dlist.rs
	src/libcollections/ring_buf.rs
	src/libcollections/slice.rs
	src/libcollections/str.rs
	src/libcollections/string.rs
	src/libcollections/vec.rs
	src/libcollections/vec_map.rs
	src/libcore/any.rs
	src/libcore/array.rs
	src/libcore/borrow.rs
	src/libcore/error.rs
	src/libcore/fmt/mod.rs
	src/libcore/iter.rs
	src/libcore/marker.rs
	src/libcore/ops.rs
	src/libcore/result.rs
	src/libcore/slice.rs
	src/libcore/str/mod.rs
	src/libregex/lib.rs
	src/libregex/re.rs
	src/librustc/lint/builtin.rs
	src/libstd/collections/hash/map.rs
	src/libstd/collections/hash/set.rs
	src/libstd/sync/mpsc/mod.rs
	src/libstd/sync/mutex.rs
	src/libstd/sync/poison.rs
	src/libstd/sync/rwlock.rs
	src/libsyntax/feature_gate.rs
	src/libsyntax/test.rs

1 files changed, 39 insertions, 41 deletions

diff --git a/src/libsyntax/test.rs b/src/libsyntax/test.rs
index c7d7b57e66e..4b6657d67a4 100644
--- a/src/libsyntax/test.rs
+++ b/src/libsyntax/test.rs
@@ -105,11 +105,11 @@ impl<'a> fold::Folder for TestHarnessGenerator<'a> {
         // Add a special __test module to the crate that will contain code
         // generated for the test harness
         let (mod_, reexport) = mk_test_module(&mut self.cx);
-        folded.module.items.push(mod_);
         match reexport {
-            Some(re) => folded.module.view_items.push(re),
+            Some(re) => folded.module.items.push(re),
             None => {}
         }
+        folded.module.items.push(mod_);
         folded
     }
 
@@ -205,22 +205,19 @@ impl<'a> fold::Folder for TestHarnessGenerator<'a> {
 
 fn mk_reexport_mod(cx: &mut TestCtxt, tests: Vec<ast::Ident>,
                    tested_submods: Vec<(ast::Ident, ast::Ident)>) -> (P<ast::Item>, ast::Ident) {
-    let mut view_items = Vec::new();
     let super_ = token::str_to_ident("super");
 
-    view_items.extend(tests.into_iter().map(|r| {
-        cx.ext_cx.view_use_simple(DUMMY_SP, ast::Public,
+    let items = tests.into_iter().map(|r| {
+        cx.ext_cx.item_use_simple(DUMMY_SP, ast::Public,
                                   cx.ext_cx.path(DUMMY_SP, vec![super_, r]))
-    }));
-    view_items.extend(tested_submods.into_iter().map(|(r, sym)| {
+    }).chain(tested_submods.into_iter().map(|(r, sym)| {
         let path = cx.ext_cx.path(DUMMY_SP, vec![super_, r, sym]);
-        cx.ext_cx.view_use_simple_(DUMMY_SP, ast::Public, r, path)
+        cx.ext_cx.item_use_simple_(DUMMY_SP, ast::Public, r, path)
     }));
 
     let reexport_mod = ast::Mod {
         inner: DUMMY_SP,
-        view_items: view_items,
-        items: Vec::new(),
+        items: items.collect(),
     };
 
     let sym = token::gensym_ident("__test_reexports");
@@ -357,8 +354,8 @@ fn is_bench_fn(cx: &TestCtxt, i: &ast::Item) -> bool {
                 let tparm_cnt = generics.ty_params.len();
                 // NB: inadequate check, but we're running
                 // well before resolve, can't get too deep.
-                input_cnt == 1u
-                    && no_output && tparm_cnt == 0u
+                input_cnt == 1us
+                    && no_output && tparm_cnt == 0us
             }
           _ => false
         }
@@ -406,24 +403,24 @@ mod __test {
 
 */
 
-fn mk_std(cx: &TestCtxt) -> ast::ViewItem {
+fn mk_std(cx: &TestCtxt) -> P<ast::Item> {
     let id_test = token::str_to_ident("test");
-    let (vi, vis) = if cx.is_test_crate {
-        (ast::ViewItemUse(
+    let (vi, vis, ident) = if cx.is_test_crate {
+        (ast::ItemUse(
             P(nospan(ast::ViewPathSimple(id_test,
-                                         path_node(vec!(id_test)),
-                                         ast::DUMMY_NODE_ID)))),
-         ast::Public)
+                                         path_node(vec!(id_test)))))),
+         ast::Public, token::special_idents::invalid)
     } else {
-        (ast::ViewItemExternCrate(id_test, None, ast::DUMMY_NODE_ID),
-         ast::Inherited)
+        (ast::ItemExternCrate(None), ast::Inherited, id_test)
     };
-    ast::ViewItem {
+    P(ast::Item {
+        id: ast::DUMMY_NODE_ID,
+        ident: ident,
         node: vi,
-        attrs: Vec::new(),
+        attrs: vec![],
         vis: vis,
         span: DUMMY_SP
-    }
+    })
 }
 
 fn mk_main(cx: &mut TestCtxt) -> P<ast::Item> {
@@ -450,8 +447,9 @@ fn mk_main(cx: &mut TestCtxt) -> P<ast::Item> {
                                                 token::str_to_ident("args")]);
     // use std::slice::AsSlice
     let as_slice_path = P(nospan(ast::ViewPathSimple(token::str_to_ident("AsSlice"),
-                                                     as_slice_path, ast::DUMMY_NODE_ID)));
-    let use_as_slice = ecx.view_use(sp, ast::Inherited, as_slice_path);
+                                                     as_slice_path)));
+    let use_as_slice = ecx.item_use(sp, ast::Inherited, as_slice_path);
+    let use_as_slice = ecx.stmt_item(sp, use_as_slice);
     // ::std::os::args()
     let os_args_path_expr = ecx.expr_path(os_args_path);
     let call_os_args = ecx.expr_call(sp, os_args_path_expr, vec![]);
@@ -469,7 +467,7 @@ fn mk_main(cx: &mut TestCtxt) -> P<ast::Item> {
     let main_attr = ecx.attribute(sp, main_meta);
     // pub fn main() { ... }
     let main_ret_ty = ecx.ty(sp, ast::TyTup(vec![]));
-    let main_body = ecx.block_all(sp, vec![use_as_slice], vec![call_test_main], None);
+    let main_body = ecx.block_all(sp, vec![use_as_slice, call_test_main], None);
     let main = ast::ItemFn(ecx.fn_decl(vec![], main_ret_ty),
                            ast::Unsafety::Normal, ::abi::Rust, empty_generics(), main_body);
     let main = P(ast::Item {
@@ -484,9 +482,9 @@ fn mk_main(cx: &mut TestCtxt) -> P<ast::Item> {
     return main;
 }
 
-fn mk_test_module(cx: &mut TestCtxt) -> (P<ast::Item>, Option<ast::ViewItem>) {
+fn mk_test_module(cx: &mut TestCtxt) -> (P<ast::Item>, Option<P<ast::Item>>) {
     // Link to test crate
-    let view_items = vec!(mk_std(cx));
+    let import = mk_std(cx);
 
     // A constant vector of test descriptors.
     let tests = mk_tests(cx);
@@ -497,40 +495,40 @@ fn mk_test_module(cx: &mut TestCtxt) -> (P<ast::Item>, Option<ast::ViewItem>) {
 
     let testmod = ast::Mod {
         inner: DUMMY_SP,
-        view_items: view_items,
-        items: vec!(mainfn, tests),
+        items: vec![import, mainfn, tests],
     };
     let item_ = ast::ItemMod(testmod);
 
     let mod_ident = token::gensym_ident("__test");
-    let item = ast::Item {
-        ident: mod_ident,
+    let item = P(ast::Item {
         id: ast::DUMMY_NODE_ID,
+        ident: mod_ident,
+        attrs: vec![],
         node: item_,
         vis: ast::Public,
         span: DUMMY_SP,
-        attrs: vec![],
-    };
+    });
     let reexport = cx.reexport_test_harness_main.as_ref().map(|s| {
         // building `use <ident> = __test::main`
         let reexport_ident = token::str_to_ident(s.get());
 
         let use_path =
             nospan(ast::ViewPathSimple(reexport_ident,
-                                       path_node(vec![mod_ident, token::str_to_ident("main")]),
-                                       ast::DUMMY_NODE_ID));
+                                       path_node(vec![mod_ident, token::str_to_ident("main")])));
 
-        ast::ViewItem {
-            node: ast::ViewItemUse(P(use_path)),
+        P(ast::Item {
+            id: ast::DUMMY_NODE_ID,
+            ident: token::special_idents::invalid,
             attrs: vec![],
+            node: ast::ItemUse(P(use_path)),
             vis: ast::Inherited,
             span: DUMMY_SP
-        }
+        })
     });
 
-    debug!("Synthetic test module:\n{}\n", pprust::item_to_string(&item));
+    debug!("Synthetic test module:\n{}\n", pprust::item_to_string(&*item));
 
-    (P(item), reexport)
+    (item, reexport)
 }
 
 fn nospan<T>(t: T) -> codemap::Spanned<T> {