test: Fix check-fast for resolve changes. rs=bustage

diff --git a/src/test/run-pass/alt-pattern-drop.rs b/src/test/run-pass/alt-pattern-drop.rs
index c90bec114ed26e3dc1cf179dba0681b32ea14865..ccc65cdab7515a2706779ca0f73c9a79f95b131d 100644 (file)
--- a/src/test/run-pass/alt-pattern-drop.rs
+++ b/src/test/run-pass/alt-pattern-drop.rs
@@ -14,7 +14,7 @@
 enum t { make_t(@int), clam, }
 
 fn foo(s: @int) {
-    let count = core::sys::refcount(s);
+    let count = ::core::sys::refcount(s);
     let x: t = make_t(s); // ref up
 
     match x {
@@ -24,20 +24,20 @@ fn foo(s: @int) {
       }
       _ => { debug!("?"); fail; }
     }
-    log(debug, core::sys::refcount(s));
-    assert (core::sys::refcount(s) == count + 1u);
-    let _ = core::sys::refcount(s); // don't get bitten by last-use.
+    log(debug, ::core::sys::refcount(s));
+    assert (::core::sys::refcount(s) == count + 1u);
+    let _ = ::core::sys::refcount(s); // don't get bitten by last-use.
 }
 
 fn main() {
     let s: @int = @0; // ref up
 
-    let count = core::sys::refcount(s);
+    let count = ::core::sys::refcount(s);
 
     foo(s); // ref up then down
 
-    log(debug, core::sys::refcount(s));
-    let count2 = core::sys::refcount(s);
-    let _ = core::sys::refcount(s); // don't get bitten by last-use.
+    log(debug, ::core::sys::refcount(s));
+    let count2 = ::core::sys::refcount(s);
+    let _ = ::core::sys::refcount(s); // don't get bitten by last-use.
     assert count == count2;
 }

diff --git a/src/test/run-pass/basic-1.rs b/src/test/run-pass/basic-1.rs
index 7f7da086df30ce042e169db9bd9131c142f21daa..87fd1443db9e3c1de236132f49105268ec2100fb 100644 (file)
--- a/src/test/run-pass/basic-1.rs
+++ b/src/test/run-pass/basic-1.rs
@@ -10,25 +10,25 @@
 // except according to those terms.
 
 
-fn a(c: core::oldcomm::Chan<int>) { core::oldcomm::send(c, 10); }
+fn a(c: ::core::oldcomm::Chan<int>) { ::core::oldcomm::send(c, 10); }
 
 fn main() {
-    let p = core::oldcomm::Port();
-    let ch = core::oldcomm::Chan(&p);
+    let p = ::core::oldcomm::Port();
+    let ch = ::core::oldcomm::Chan(&p);
     task::spawn(|| a(ch) );
     task::spawn(|| a(ch) );
     let mut n: int = 0;
-    n = core::oldcomm::recv(p);
-    n = core::oldcomm::recv(p);
+    n = ::core::oldcomm::recv(p);
+    n = ::core::oldcomm::recv(p);
     //    debug!("Finished.");
 }
 
-fn b(c: core::oldcomm::Chan<int>) {
+fn b(c: ::core::oldcomm::Chan<int>) {
     //    debug!("task b0");
     //    debug!("task b1");
     //    debug!("task b2");
     //    debug!("task b3");
     //    debug!("task b4");
     //    debug!("task b5");
-    core::oldcomm::send(c, 10);
+    ::core::oldcomm::send(c, 10);
 }

diff --git a/src/test/run-pass/basic-2.rs b/src/test/run-pass/basic-2.rs
index 36ed4c5162b67f611313333a8ceb83420c863cc1..0e542e157cf934ecdd1905a6799e368ecbf2a06c 100644 (file)
--- a/src/test/run-pass/basic-2.rs
+++ b/src/test/run-pass/basic-2.rs
@@ -10,28 +10,28 @@
 // except according to those terms.
 
 
-fn a(c: core::oldcomm::Chan<int>) {
+fn a(c: ::core::oldcomm::Chan<int>) {
     debug!("task a0");
     debug!("task a1");
-    core::oldcomm::send(c, 10);
+    ::core::oldcomm::send(c, 10);
 }
 
 fn main() {
-    let p = core::oldcomm::Port();
-    let ch = core::oldcomm::Chan(&p);
+    let p = ::core::oldcomm::Port();
+    let ch = ::core::oldcomm::Chan(&p);
     task::spawn(|| a(ch) );
     task::spawn(|| b(ch) );
     let mut n: int = 0;
-    n = core::oldcomm::recv(p);
-    n = core::oldcomm::recv(p);
+    n = ::core::oldcomm::recv(p);
+    n = ::core::oldcomm::recv(p);
     debug!("Finished.");
 }
 
-fn b(c: core::oldcomm::Chan<int>) {
+fn b(c: ::core::oldcomm::Chan<int>) {
     debug!("task b0");
     debug!("task b1");
     debug!("task b2");
     debug!("task b2");
     debug!("task b3");
-    core::oldcomm::send(c, 10);
+    ::core::oldcomm::send(c, 10);
 }

diff --git a/src/test/run-pass/basic.rs b/src/test/run-pass/basic.rs
index a84bfdcdbb7ee4c8acd585357f6753534ccc9fec..ac029b63eef4075d344c886dc796aafa7ccd54f9 100644 (file)
--- a/src/test/run-pass/basic.rs
+++ b/src/test/run-pass/basic.rs
@@ -10,7 +10,7 @@
 // except according to those terms.
 
 
-fn a(c: core::oldcomm::Chan<int>) {
+fn a(c: ::core::oldcomm::Chan<int>) {
     if true {
         debug!("task a");
         debug!("task a");
@@ -18,7 +18,7 @@ fn a(c: core::oldcomm::Chan<int>) {
         debug!("task a");
         debug!("task a");
     }
-    core::oldcomm::send(c, 10);
+    ::core::oldcomm::send(c, 10);
 }
 
 fn k(x: int) -> int { return 15; }
@@ -34,18 +34,18 @@ fn main() {
     let mut n: int = 2 + 3 * 7;
     let s: ~str = ~"hello there";
     let p = oldcomm::Port();
-    let ch = core::oldcomm::Chan(&p);
+    let ch = ::core::oldcomm::Chan(&p);
     task::spawn(|| a(ch) );
     task::spawn(|| b(ch) );
     let mut x: int = 10;
     x = g(n, s);
     log(debug, x);
-    n = core::oldcomm::recv(p);
-    n = core::oldcomm::recv(p);
+    n = ::core::oldcomm::recv(p);
+    n = ::core::oldcomm::recv(p);
     debug!("children finished, root finishing");
 }
 
-fn b(c: core::oldcomm::Chan<int>) {
+fn b(c: ::core::oldcomm::Chan<int>) {
     if true {
         debug!("task b");
         debug!("task b");
@@ -54,5 +54,5 @@ fn b(c: core::oldcomm::Chan<int>) {
         debug!("task b");
         debug!("task b");
     }
-    core::oldcomm::send(c, 10);
+    ::core::oldcomm::send(c, 10);
 }

diff --git a/src/test/run-pass/binops.rs b/src/test/run-pass/binops.rs
index 72299e2b329c1e52878f8f40c6cb6a012a8b4176..04cc55b22640c865ee76dfd82b8dbc1508df2671 100644 (file)
--- a/src/test/run-pass/binops.rs
+++ b/src/test/run-pass/binops.rs
@@ -63,9 +63,9 @@ fn test_box() {
 }
 
 fn test_ptr() unsafe {
-    let p1: *u8 = core::cast::reinterpret_cast(&0);
-    let p2: *u8 = core::cast::reinterpret_cast(&0);
-    let p3: *u8 = core::cast::reinterpret_cast(&1);
+    let p1: *u8 = ::core::cast::reinterpret_cast(&0);
+    let p2: *u8 = ::core::cast::reinterpret_cast(&0);
+    let p3: *u8 = ::core::cast::reinterpret_cast(&1);
 
     assert p1 == p2;
     assert p1 != p3;
@@ -110,8 +110,8 @@ fn test_class() {
   
   unsafe {
   error!("q = %x, r = %x",
-         (core::cast::reinterpret_cast::<*p, uint>(&ptr::addr_of(&q))),
-         (core::cast::reinterpret_cast::<*p, uint>(&ptr::addr_of(&r))));
+         (::core::cast::reinterpret_cast::<*p, uint>(&ptr::addr_of(&q))),
+         (::core::cast::reinterpret_cast::<*p, uint>(&ptr::addr_of(&r))));
   }
   assert(q == r);
   r.y = 17;

diff --git a/src/test/run-pass/capture_nil.rs b/src/test/run-pass/capture_nil.rs
index 8f9049ac27b2baa7c8f6186ab83c891b75d68d3a..893912d5c05897a159619cbb2865644dca1f8740 100644 (file)
--- a/src/test/run-pass/capture_nil.rs
+++ b/src/test/run-pass/capture_nil.rs
@@ -24,9 +24,9 @@
 // course preferable, as the value itself is
 // irrelevant).
 
-fn foo(&&x: ()) -> core::oldcomm::Port<()> {
-    let p = core::oldcomm::Port();
-    let c = core::oldcomm::Chan(&p);
+fn foo(&&x: ()) -> ::core::oldcomm::Port<()> {
+    let p = ::core::oldcomm::Port();
+    let c = ::core::oldcomm::Chan(&p);
     do task::spawn() |copy c, copy x| {
         c.send(x);
     }

diff --git a/src/test/run-pass/cci_capture_clause.rs b/src/test/run-pass/cci_capture_clause.rs
index a439d2af8fc020a715e7179d97f458d5c20db355..4e75d19dba0f14b86b8b1f2aa50dd1ee9f9bd446 100644 (file)
--- a/src/test/run-pass/cci_capture_clause.rs
+++ b/src/test/run-pass/cci_capture_clause.rs
@@ -18,7 +18,7 @@
 
 extern mod cci_capture_clause;
 
-use core::oldcomm::recv;
+use ::core::oldcomm::recv;
 
 fn main() {
     cci_capture_clause::foo(()).recv()

diff --git a/src/test/run-pass/chan-leak.rs b/src/test/run-pass/chan-leak.rs
index bb429a07f39dbc5ea0b9bdf777b8402cf735aac7..43825b03c296d8c9e139597a6a09f62a091d9557 100644 (file)
--- a/src/test/run-pass/chan-leak.rs
+++ b/src/test/run-pass/chan-leak.rs
@@ -10,32 +10,32 @@
 
 // Issue #763
 
-enum request { quit, close(core::oldcomm::Chan<bool>), }
+enum request { quit, close(::core::oldcomm::Chan<bool>), }
 
-type ctx = core::oldcomm::Chan<request>;
+type ctx = ::core::oldcomm::Chan<request>;
 
-fn request_task(c: core::oldcomm::Chan<ctx>) {
-    let p = core::oldcomm::Port();
-    core::oldcomm::send(c, core::oldcomm::Chan(&p));
+fn request_task(c: ::core::oldcomm::Chan<ctx>) {
+    let p = ::core::oldcomm::Port();
+    ::core::oldcomm::send(c, ::core::oldcomm::Chan(&p));
     let mut req: request;
-    req = core::oldcomm::recv(p);
+    req = ::core::oldcomm::recv(p);
     // Need to drop req before receiving it again
-    req = core::oldcomm::recv(p);
+    req = ::core::oldcomm::recv(p);
 }
 
 fn new_cx() -> ctx {
-    let p = core::oldcomm::Port();
-    let ch = core::oldcomm::Chan(&p);
+    let p = ::core::oldcomm::Port();
+    let ch = ::core::oldcomm::Chan(&p);
     let t = task::spawn(|| request_task(ch) );
     let mut cx: ctx;
-    cx = core::oldcomm::recv(p);
+    cx = ::core::oldcomm::recv(p);
     return cx;
 }
 
 fn main() {
     let cx = new_cx();
 
-    let p = core::oldcomm::Port::<bool>();
-    core::oldcomm::send(cx, close(core::oldcomm::Chan(&p)));
-    core::oldcomm::send(cx, quit);
+    let p = ::core::oldcomm::Port::<bool>();
+    ::core::oldcomm::send(cx, close(::core::oldcomm::Chan(&p)));
+    ::core::oldcomm::send(cx, quit);
 }

diff --git a/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs b/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs
index 5d53453ffc00564c11bd740c41879c09a62b2737..7c022dc8441a0e19a70bb6f63e8364e79003575a 100644 (file)
--- a/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs
+++ b/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs
@@ -11,7 +11,7 @@
 // xfail-fast
 // aux-build:cci_class_cast.rs
 extern mod cci_class_cast;
-use core::to_str::ToStr;
+use ::core::to_str::ToStr;
 use cci_class_cast::kitty::*;
 
 fn print_out<T: ToStr>(thing: T, expected: ~str) {

diff --git a/src/test/run-pass/class-separate-impl.rs b/src/test/run-pass/class-separate-impl.rs
index eb3728f2c6fc3cdbf1d17079883567c459896f32..9454dbf9bcb45c586bd7c5945b2198274f9a4a23 100644 (file)
--- a/src/test/run-pass/class-separate-impl.rs
+++ b/src/test/run-pass/class-separate-impl.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 // xfail-fast
-use core::to_str::*;
+use ::core::to_str::*;
 
 struct cat {
   priv mut meows : uint,

diff --git a/src/test/run-pass/coherence-impl-in-fn.rs b/src/test/run-pass/coherence-impl-in-fn.rs
index 90cd3397c80e54a8171b62c06f93f1c4a0b4d9e8..e014ffe4bef4786e0650ce28faa8175b77a94d6f 100644 (file)
--- a/src/test/run-pass/coherence-impl-in-fn.rs
+++ b/src/test/run-pass/coherence-impl-in-fn.rs
@@ -10,7 +10,7 @@
 
 fn main() {
     enum x { foo }
-    impl x : core::cmp::Eq {
+    impl x : ::core::cmp::Eq {
         pure fn eq(&self, other: &x) -> bool {
             (*self) as int == (*other) as int
         }

diff --git a/src/test/run-pass/comm.rs b/src/test/run-pass/comm.rs
index 453ae679523191f378ef8d9e296179bd65f786d7..7a79d2360684d02f29be5d060458b252db5ac483 100644 (file)
--- a/src/test/run-pass/comm.rs
+++ b/src/test/run-pass/comm.rs
@@ -12,16 +12,16 @@
 
 fn main() {
     let p = oldcomm::Port();
-    let ch = core::oldcomm::Chan(&p);
+    let ch = ::core::oldcomm::Chan(&p);
     let t = task::spawn(|| child(ch) );
-    let y = core::oldcomm::recv(p);
+    let y = ::core::oldcomm::recv(p);
     error!("received");
     log(error, y);
     assert (y == 10);
 }
 
-fn child(c: core::oldcomm::Chan<int>) {
+fn child(c: ::core::oldcomm::Chan<int>) {
     error!("sending");
-    core::oldcomm::send(c, 10);
+    ::core::oldcomm::send(c, 10);
     error!("value sent");
 }

diff --git a/src/test/run-pass/core-export-f64-sqrt.rs b/src/test/run-pass/core-export-f64-sqrt.rs
index a78ca37172b28d94220033adf2787f614536786d..9b080206fcdea58ea12380e3e450c52e26413825 100644 (file)
--- a/src/test/run-pass/core-export-f64-sqrt.rs
+++ b/src/test/run-pass/core-export-f64-sqrt.rs
@@ -14,5 +14,5 @@ fn main() {
 
     let digits: uint = 10 as uint;
 
-    core::io::println(float::to_str(f64::sqrt(42.0f64) as float, digits));
+    ::core::io::println(float::to_str(f64::sqrt(42.0f64) as float, digits));
 }

diff --git a/src/test/run-pass/decl-with-recv.rs b/src/test/run-pass/decl-with-recv.rs
index 4b4d6a86806d1bc7e812efa75bce5a0f4dda175c..a3679f71a6b1bb7a3096daa1b234e7336bc48a28 100644 (file)
--- a/src/test/run-pass/decl-with-recv.rs
+++ b/src/test/run-pass/decl-with-recv.rs
@@ -11,12 +11,12 @@
 
 
 fn main() {
-    let po = core::oldcomm::Port();
-    let ch = core::oldcomm::Chan(&po);
-    core::oldcomm::send(ch, 10);
-    let i = core::oldcomm::recv(po);
+    let po = ::core::oldcomm::Port();
+    let ch = ::core::oldcomm::Chan(&po);
+    ::core::oldcomm::send(ch, 10);
+    let i = ::core::oldcomm::recv(po);
     assert (i == 10);
-    core::oldcomm::send(ch, 11);
-    let j = core::oldcomm::recv(po);
+    ::core::oldcomm::send(ch, 11);
+    let j = ::core::oldcomm::recv(po);
     assert (j == 11);
 }

diff --git a/src/test/run-pass/deriving-via-extension-iter-bytes-enum.rs b/src/test/run-pass/deriving-via-extension-iter-bytes-enum.rs
index 1f29a08a804682a4788fc2f954daf965b21cbf06..849ad64270de9b80b40c2b0590bb8d8d27570c7a 100644 (file)
--- a/src/test/run-pass/deriving-via-extension-iter-bytes-enum.rs
+++ b/src/test/run-pass/deriving-via-extension-iter-bytes-enum.rs
@@ -1,3 +1,5 @@
+// xfail-fast
+
 // Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.

diff --git a/src/test/run-pass/deriving-via-extension-iter-bytes-struct.rs b/src/test/run-pass/deriving-via-extension-iter-bytes-struct.rs
index a71d51cf21c0da9271a406e265bded7d45316fb4..5855b1a530ba3ef362abe3545dd08fd8f4927cde 100644 (file)
--- a/src/test/run-pass/deriving-via-extension-iter-bytes-struct.rs
+++ b/src/test/run-pass/deriving-via-extension-iter-bytes-struct.rs
@@ -1,3 +1,5 @@
+// xfail-fast
+
 // Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.

diff --git a/src/test/run-pass/deriving-via-extension-type-params.rs b/src/test/run-pass/deriving-via-extension-type-params.rs
index c0501a09207408d72b0e80089b51748bd077beb9..b1b196e6986a43d77a880e0d44996e0c3a97a9a1 100644 (file)
--- a/src/test/run-pass/deriving-via-extension-type-params.rs
+++ b/src/test/run-pass/deriving-via-extension-type-params.rs
@@ -1,3 +1,5 @@
+// xfail-fast
+
 // Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.

diff --git a/src/test/run-pass/drop-trait-generic.rs b/src/test/run-pass/drop-trait-generic.rs
index 4906f0e70b96eb0d62f68095ed11db9dec359bc6..238f3b8b587a3e5f890aafe70cbfb72dcaa8267a 100644 (file)
--- a/src/test/run-pass/drop-trait-generic.rs
+++ b/src/test/run-pass/drop-trait-generic.rs
@@ -12,7 +12,7 @@ struct S<T> {
     x: T
 }
 
-impl<T> S<T> : core::ops::Drop {
+impl<T> S<T> : ::core::ops::Drop {
     fn finalize(&self) {
         io::println("bye");
     }

diff --git a/src/test/run-pass/export-non-interference3.rs b/src/test/run-pass/export-non-interference3.rs
index 3b4ab709f6d780b47337706397b9d13afa051648..5f8a74203e4e8aba2cf11f224a79077257bdf020 100644 (file)
--- a/src/test/run-pass/export-non-interference3.rs
+++ b/src/test/run-pass/export-non-interference3.rs
@@ -1,3 +1,5 @@
+// xfail-fast
+
 // Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.

diff --git a/src/test/run-pass/foreign2.rs b/src/test/run-pass/foreign2.rs
index 4b7b762f4d17c45e6efa5f047bbd2cd3d6d15cb5..0018a1d62f68644fdbae688051509efdab47dcac 100644 (file)
--- a/src/test/run-pass/foreign2.rs
+++ b/src/test/run-pass/foreign2.rs
@@ -23,7 +23,7 @@
 extern mod libc {
     #[legacy_exports];
     fn write(fd: int, buf: *u8,
-             count: core::libc::size_t) -> core::libc::ssize_t;
+             count: ::core::libc::size_t) -> ::core::libc::ssize_t;
 }
 
 #[abi = "cdecl"]

diff --git a/src/test/run-pass/import-glob-crate.rs b/src/test/run-pass/import-glob-crate.rs
index eba69134c4f0a280dce9e84d0d5c0ec114a7fd60..bde4b96a927410e45a086a16574ab426e2aafbeb 100644 (file)
--- a/src/test/run-pass/import-glob-crate.rs
+++ b/src/test/run-pass/import-glob-crate.rs
@@ -12,7 +12,7 @@
 
 
 extern mod std;
-use core::vec::*;
+use ::core::vec::*;
 
 fn main() {
     let mut v = from_elem(0u, 0);

diff --git a/src/test/run-pass/issue-2214.rs b/src/test/run-pass/issue-2214.rs
index efa6d05f9da767f460fdde69801685d6eef9055b..7ba9583a77f2996c107980f35addc47e36891870 100644 (file)
--- a/src/test/run-pass/issue-2214.rs
+++ b/src/test/run-pass/issue-2214.rs
@@ -10,9 +10,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::cast;
-use core::libc::{c_double, c_int};
-use core::f64::*;
+use ::core::cast;
+use ::core::libc::{c_double, c_int};
+use ::core::f64::*;
 
 fn to_c_int(v: &mut int) -> &mut c_int unsafe {
     cast::reinterpret_cast(&v)

diff --git a/src/test/run-pass/issue-2718.rs b/src/test/run-pass/issue-2718.rs
index 71afce93421e054fdfd3d13af465021bd51b3292..ebc97f79aefd8a680fc0695c9f6936330d74f4de 100644 (file)
--- a/src/test/run-pass/issue-2718.rs
+++ b/src/test/run-pass/issue-2718.rs
@@ -12,7 +12,7 @@
 
 // tjc: I don't know why
 pub mod pipes {
-    use core::cast::{forget, transmute};
+    use ::core::cast::{forget, transmute};
 
     pub enum state {
         empty,
@@ -50,7 +50,7 @@ mod rusti {
       pub fn atomic_xchg_rel(_dst: &mut int, _src: int) -> int { fail; }
     }
 
-    // We should consider moving this to core::unsafe, although I
+    // We should consider moving this to ::core::unsafe, although I
     // suspect graydon would want us to use void pointers instead.
     pub unsafe fn uniquify<T>(+x: *T) -> ~T {
         unsafe { cast::transmute(move x) }
@@ -212,8 +212,8 @@ pub fn entangle<T: Owned>() -> (send_packet<T>, recv_packet<T>) {
 }
 
 pub mod pingpong {
-    use core::cast;
-    use core::ptr;
+    use ::core::cast;
+    use ::core::ptr;
 
     pub enum ping = ::pipes::send_packet<pong>;
     pub enum pong = ::pipes::send_packet<ping>;
@@ -241,7 +241,7 @@ pub fn init() -> (client::ping, server::ping) {
     }
 
     pub mod client {
-        use core::option;
+        use ::core::option;
         use pingpong;
 
         pub type ping = ::pipes::send_packet<pingpong::ping>;

diff --git a/src/test/run-pass/issue-3559.rs b/src/test/run-pass/issue-3559.rs
index da7746681f281d449c9f6b8cfd574e7165c78979..cca4a25569bee293989dc5785fd25fa1c58a7809 100644 (file)
--- a/src/test/run-pass/issue-3559.rs
+++ b/src/test/run-pass/issue-3559.rs
@@ -13,7 +13,7 @@
 // rustc --test map_to_str.rs && ./map_to_str
 extern mod std;
 
-use core::io::{WriterUtil};
+use ::core::io::{WriterUtil};
 use std::map::*;
 
 #[cfg(test)]

diff --git a/src/test/run-pass/issue-3656.rs b/src/test/run-pass/issue-3656.rs
index 66c2a4672b4b0c8a90a43acbb3cd1da147660217..0cdc394948db6ef947fa85346c14b672f4881ebc 100644 (file)
--- a/src/test/run-pass/issue-3656.rs
+++ b/src/test/run-pass/issue-3656.rs
@@ -13,7 +13,7 @@
 // Incorrect struct size computation in the FFI, because of not taking
 // the alignment of elements into account.
 
-use core::libc::*;
+use ::core::libc::*;
 
 struct KEYGEN {
     hash_algorithm: [c_uint * 2],

diff --git a/src/test/run-pass/issue-507.rs b/src/test/run-pass/issue-507.rs
index 556e597a86da7c6637433e9c1affc9a306aa0c85..52f202a2deb48497125a9c6c5aebde401f16678b 100644 (file)
--- a/src/test/run-pass/issue-507.rs
+++ b/src/test/run-pass/issue-507.rs
@@ -15,19 +15,19 @@
    https://github.com/graydon/rust/issues/507
 */
 
-fn grandchild(c: core::oldcomm::Chan<int>) { core::oldcomm::send(c, 42); }
+fn grandchild(c: ::core::oldcomm::Chan<int>) { ::core::oldcomm::send(c, 42); }
 
-fn child(c: core::oldcomm::Chan<int>) {
+fn child(c: ::core::oldcomm::Chan<int>) {
     task::spawn(|| grandchild(c) )
 }
 
 fn main() {
-    let p = core::oldcomm::Port();
-    let ch = core::oldcomm::Chan(&p);
+    let p = ::core::oldcomm::Port();
+    let ch = ::core::oldcomm::Chan(&p);
 
     task::spawn(|| child(ch) );
 
-    let x: int = core::oldcomm::recv(p);
+    let x: int = ::core::oldcomm::recv(p);
 
     log(debug, x);
 

diff --git a/src/test/run-pass/issue-687.rs b/src/test/run-pass/issue-687.rs
index 9cfec06007c95fd9715109d054bdab9ff2136b6e..53827bb63fa3cfaeac61d354109cfb658fa77e48 100644 (file)
--- a/src/test/run-pass/issue-687.rs
+++ b/src/test/run-pass/issue-687.rs
@@ -10,18 +10,18 @@
 
 enum msg { closed, received(~[u8]), }
 
-fn producer(c: core::oldcomm::Chan<~[u8]>) {
-    core::oldcomm::send(c, ~[1u8, 2u8, 3u8, 4u8]);
+fn producer(c: ::core::oldcomm::Chan<~[u8]>) {
+    ::core::oldcomm::send(c, ~[1u8, 2u8, 3u8, 4u8]);
     let empty: ~[u8] = ~[];
-    core::oldcomm::send(c, empty);
+    ::core::oldcomm::send(c, empty);
 }
 
-fn packager(cb: core::oldcomm::Chan<core::oldcomm::Chan<~[u8]>>, msg: core::oldcomm::Chan<msg>) {
-    let p: core::oldcomm::Port<~[u8]> = core::oldcomm::Port();
-    core::oldcomm::send(cb, core::oldcomm::Chan(&p));
+fn packager(cb: ::core::oldcomm::Chan<::core::oldcomm::Chan<~[u8]>>, msg: ::core::oldcomm::Chan<msg>) {
+    let p: ::core::oldcomm::Port<~[u8]> = ::core::oldcomm::Port();
+    ::core::oldcomm::send(cb, ::core::oldcomm::Chan(&p));
     loop {
         debug!("waiting for bytes");
-        let data = core::oldcomm::recv(p);
+        let data = ::core::oldcomm::recv(p);
         debug!("got bytes");
         if vec::len(data) == 0u {
             debug!("got empty bytes, quitting");
@@ -29,26 +29,26 @@ fn packager(cb: core::oldcomm::Chan<core::oldcomm::Chan<~[u8]>>, msg: core::oldc
         }
         debug!("sending non-empty buffer of length");
         log(debug, vec::len(data));
-        core::oldcomm::send(msg, received(data));
+        ::core::oldcomm::send(msg, received(data));
         debug!("sent non-empty buffer");
     }
     debug!("sending closed message");
-    core::oldcomm::send(msg, closed);
+    ::core::oldcomm::send(msg, closed);
     debug!("sent closed message");
 }
 
 fn main() {
-    let p: core::oldcomm::Port<msg> = core::oldcomm::Port();
-    let ch = core::oldcomm::Chan(&p);
-    let recv_reader: core::oldcomm::Port<core::oldcomm::Chan<~[u8]>> = core::oldcomm::Port();
-    let recv_reader_chan = core::oldcomm::Chan(&recv_reader);
+    let p: ::core::oldcomm::Port<msg> = ::core::oldcomm::Port();
+    let ch = ::core::oldcomm::Chan(&p);
+    let recv_reader: ::core::oldcomm::Port<::core::oldcomm::Chan<~[u8]>> = ::core::oldcomm::Port();
+    let recv_reader_chan = ::core::oldcomm::Chan(&recv_reader);
     let pack = task::spawn(|| packager(recv_reader_chan, ch) );
 
-    let source_chan: core::oldcomm::Chan<~[u8]> = core::oldcomm::recv(recv_reader);
+    let source_chan: ::core::oldcomm::Chan<~[u8]> = ::core::oldcomm::recv(recv_reader);
     let prod = task::spawn(|| producer(source_chan) );
 
     loop {
-        let msg = core::oldcomm::recv(p);
+        let msg = ::core::oldcomm::recv(p);
         match msg {
           closed => { debug!("Got close message"); break; }
           received(data) => {

diff --git a/src/test/run-pass/issue-783.rs b/src/test/run-pass/issue-783.rs
index 3820ff770227cedbab120a3cc1e9aadee95c48b9..75404c01fc53aa2a605c88f810524c95f0e6cfc1 100644 (file)
--- a/src/test/run-pass/issue-783.rs
+++ b/src/test/run-pass/issue-783.rs
@@ -10,14 +10,14 @@
 
 fn a() {
     fn doit() {
-        fn b(c: core::oldcomm::Chan<core::oldcomm::Chan<int>>) {
-            let p = core::oldcomm::Port();
-            core::oldcomm::send(c, core::oldcomm::Chan(&p));
+        fn b(c: ::core::oldcomm::Chan<::core::oldcomm::Chan<int>>) {
+            let p = ::core::oldcomm::Port();
+            ::core::oldcomm::send(c, ::core::oldcomm::Chan(&p));
         }
-        let p = core::oldcomm::Port();
-        let ch = core::oldcomm::Chan(&p);
+        let p = ::core::oldcomm::Port();
+        let ch = ::core::oldcomm::Chan(&p);
         task::spawn(|| b(ch) );
-        core::oldcomm::recv(p);
+        ::core::oldcomm::recv(p);
     }
     let mut i = 0;
     while i < 100 {

diff --git a/src/test/run-pass/ivec-tag.rs b/src/test/run-pass/ivec-tag.rs
index 7066b5f63cd60d774fb5caf627b4062ec99e8736..31651ab7c20a63a50b333eee00565a47c9e10ee0 100644 (file)
--- a/src/test/run-pass/ivec-tag.rs
+++ b/src/test/run-pass/ivec-tag.rs
@@ -1,13 +1,13 @@
-fn producer(c: core::oldcomm::Chan<~[u8]>) {
-    core::oldcomm::send(c,
+fn producer(c: ::core::oldcomm::Chan<~[u8]>) {
+    ::core::oldcomm::send(c,
          ~[1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8, 9u8, 10u8, 11u8, 12u8,
           13u8]);
 }
 
 fn main() {
-    let p: core::oldcomm::Port<~[u8]> = core::oldcomm::Port();
-    let ch = core::oldcomm::Chan(&p);
+    let p: ::core::oldcomm::Port<~[u8]> = ::core::oldcomm::Port();
+    let ch = ::core::oldcomm::Chan(&p);
     let prod = task::spawn(|| producer(ch) );
 
-    let data: ~[u8] = core::oldcomm::recv(p);
+    let data: ~[u8] = ::core::oldcomm::recv(p);
 }

diff --git a/src/test/run-pass/lazychan.rs b/src/test/run-pass/lazychan.rs
index 34244c2ef01cbb7501887764346f6acb91f59dba..4e5ce6cd0915fa7ef6b2939bd91630fc648f03f1 100644 (file)
--- a/src/test/run-pass/lazychan.rs
+++ b/src/test/run-pass/lazychan.rs
@@ -10,21 +10,21 @@
 // except according to those terms.
 
 fn main() {
-    let p = core::oldcomm::Port();
-    let ch = core::oldcomm::Chan(&p);
+    let p = ::core::oldcomm::Port();
+    let ch = ::core::oldcomm::Chan(&p);
     let mut y: int;
 
     task::spawn(|| child(ch) );
-    y = core::oldcomm::recv(p);
+    y = ::core::oldcomm::recv(p);
     debug!("received 1");
     log(debug, y);
     assert (y == 10);
 
     task::spawn(|| child(ch) );
-    y = core::oldcomm::recv(p);
+    y = ::core::oldcomm::recv(p);
     debug!("received 2");
     log(debug, y);
     assert (y == 10);
 }
 
-fn child(c: core::oldcomm::Chan<int>) { core::oldcomm::send(c, 10); }
+fn child(c: ::core::oldcomm::Chan<int>) { ::core::oldcomm::send(c, 10); }

diff --git a/src/test/run-pass/mod-view-items.rs b/src/test/run-pass/mod-view-items.rs
index dd5f7484f10374917fdf6b36bb1329abe87bad96..81424a7a8f940ca81f62f705de111738157fa425 100644 (file)
--- a/src/test/run-pass/mod-view-items.rs
+++ b/src/test/run-pass/mod-view-items.rs
@@ -18,7 +18,7 @@
 
 mod m {
     #[legacy_exports];
-    use core::vec;
+    use ::core::vec;
     fn f() -> ~[int] { vec::from_elem(1u, 0) }
 }
 

diff --git a/src/test/run-pass/pipe-pingpong-bounded.rs b/src/test/run-pass/pipe-pingpong-bounded.rs
index 803f7f06b512ccf6ec2448d78aa6e08813d06497..a00644fa8db56f8eb995c31a3c50b6d57d781918 100644 (file)
--- a/src/test/run-pass/pipe-pingpong-bounded.rs
+++ b/src/test/run-pass/pipe-pingpong-bounded.rs
@@ -18,8 +18,8 @@
 // This was generated initially by the pipe compiler, but it's been
 // modified in hopefully straightforward ways.
 mod pingpong {
-    use core::pipes::*;
-    use core::ptr;
+    use ::core::pipes::*;
+    use ::core::ptr;
 
     pub type packets = {
         ping: Packet<ping>,
@@ -43,7 +43,7 @@ pub fn init() -> (client::ping, server::ping) {
     pub enum ping = server::pong;
     pub enum pong = client::ping;
     pub mod client {
-        use core::ptr;
+        use ::core::ptr;
 
         pub fn ping(+pipe: ping) -> pong {
             {
@@ -61,7 +61,7 @@ pub fn ping(+pipe: ping) -> pong {
                                                   ::pingpong::packets>;
     }
     pub mod server {
-        use core::ptr;
+        use ::core::ptr;
 
         pub type ping = pipes::RecvPacketBuffered<::pingpong::ping,
         ::pingpong::packets>;

diff --git a/src/test/run-pass/pipe-pingpong-proto.rs b/src/test/run-pass/pipe-pingpong-proto.rs
index 7fb77cba3bde99fea7fb89a46e138d83f81a1bfa..49eb5c9e63c5a5eaae1ea248ecde3f10f5039e57 100644 (file)
--- a/src/test/run-pass/pipe-pingpong-proto.rs
+++ b/src/test/run-pass/pipe-pingpong-proto.rs
@@ -12,7 +12,7 @@
 
 // An example to make sure the protocol parsing syntax extension works.
 
-use core::option;
+use ::core::option;
 
 proto! pingpong (
     ping:send {
@@ -25,7 +25,7 @@
 )
 
 mod test {
-    use core::pipes::recv;
+    use ::core::pipes::recv;
     use pingpong::{ping, pong};
 
     pub fn client(-chan: ::pingpong::client::ping) {

diff --git a/src/test/run-pass/rt-circular-buffer.rs b/src/test/run-pass/rt-circular-buffer.rs
index dca62e0f9dffa6e6a9c72a15308f2a80a25e4920..1ddeee336e3c0d4f65d1e261ba3596f5e9191809 100644 (file)
--- a/src/test/run-pass/rt-circular-buffer.rs
+++ b/src/test/run-pass/rt-circular-buffer.rs
@@ -13,7 +13,7 @@
 // Regression tests for circular_buffer when using a unit
 // that has a size that is not a power of two
 
-// A 12-byte unit to core::oldcomm::send over the channel
+// A 12-byte unit to ::core::oldcomm::send over the channel
 type record = {val1: u32, val2: u32, val3: u32};
 
 
@@ -22,52 +22,52 @@
 // power of two so needs to be rounded up. Don't trigger any
 // assertions.
 fn test_init() {
-    let myport = core::oldcomm::Port();
-    let mychan = core::oldcomm::Chan(&myport);
+    let myport = ::core::oldcomm::Port();
+    let mychan = ::core::oldcomm::Chan(&myport);
     let val: record = {val1: 0u32, val2: 0u32, val3: 0u32};
-    core::oldcomm::send(mychan, val);
+    ::core::oldcomm::send(mychan, val);
 }
 
 
 // Dump lots of items into the channel so it has to grow.
 // Don't trigger any assertions.
 fn test_grow() {
-    let myport = core::oldcomm::Port();
-    let mychan = core::oldcomm::Chan(&myport);
+    let myport = ::core::oldcomm::Port();
+    let mychan = ::core::oldcomm::Chan(&myport);
     for uint::range(0u, 100u) |i| {
         let val: record = {val1: 0u32, val2: 0u32, val3: 0u32};
-        core::oldcomm::send(mychan, val);
+        ::core::oldcomm::send(mychan, val);
     }
 }
 
 
 // Don't allow the buffer to shrink below it's original size
 fn test_shrink1() {
-    let myport = core::oldcomm::Port();
-    let mychan = core::oldcomm::Chan(&myport);
-    core::oldcomm::send(mychan, 0i8);
-    let x = core::oldcomm::recv(myport);
+    let myport = ::core::oldcomm::Port();
+    let mychan = ::core::oldcomm::Chan(&myport);
+    ::core::oldcomm::send(mychan, 0i8);
+    let x = ::core::oldcomm::recv(myport);
 }
 
 fn test_shrink2() {
-    let myport = core::oldcomm::Port();
-    let mychan = core::oldcomm::Chan(&myport);
+    let myport = ::core::oldcomm::Port();
+    let mychan = ::core::oldcomm::Chan(&myport);
     for uint::range(0u, 100u) |_i| {
         let val: record = {val1: 0u32, val2: 0u32, val3: 0u32};
-        core::oldcomm::send(mychan, val);
+        ::core::oldcomm::send(mychan, val);
     }
-    for uint::range(0u, 100u) |_i| { let x = core::oldcomm::recv(myport); }
+    for uint::range(0u, 100u) |_i| { let x = ::core::oldcomm::recv(myport); }
 }
 
 
 // Test rotating the buffer when the unit size is not a power of two
 fn test_rotate() {
-    let myport = core::oldcomm::Port();
-    let mychan = core::oldcomm::Chan(&myport);
+    let myport = ::core::oldcomm::Port();
+    let mychan = ::core::oldcomm::Chan(&myport);
     for uint::range(0u, 100u) |i| {
         let val = {val1: i as u32, val2: i as u32, val3: i as u32};
-        core::oldcomm::send(mychan, val);
-        let x = core::oldcomm::recv(myport);
+        ::core::oldcomm::send(mychan, val);
+        let x = ::core::oldcomm::recv(myport);
         assert (x.val1 == i as u32);
         assert (x.val2 == i as u32);
         assert (x.val3 == i as u32);
@@ -78,16 +78,16 @@ fn test_rotate() {
 // Test rotating and growing the buffer when
 // the unit size is not a power of two
 fn test_rotate_grow() {
-    let myport = core::oldcomm::Port::<record>();
-    let mychan = core::oldcomm::Chan(&myport);
+    let myport = ::core::oldcomm::Port::<record>();
+    let mychan = ::core::oldcomm::Chan(&myport);
     for uint::range(0u, 10u) |j| {
         for uint::range(0u, 10u) |i| {
             let val: record =
                 {val1: i as u32, val2: i as u32, val3: i as u32};
-            core::oldcomm::send(mychan, val);
+            ::core::oldcomm::send(mychan, val);
         }
         for uint::range(0u, 10u) |i| {
-            let x = core::oldcomm::recv(myport);
+            let x = ::core::oldcomm::recv(myport);
             assert (x.val1 == i as u32);
             assert (x.val2 == i as u32);
             assert (x.val3 == i as u32);

diff --git a/src/test/run-pass/send-resource.rs b/src/test/run-pass/send-resource.rs
index a85b01acc8eddb6016893f7b242b19d1428bbc7e..39ef99a72b6114a129410f810e79eac2d9a0c472 100644 (file)
--- a/src/test/run-pass/send-resource.rs
+++ b/src/test/run-pass/send-resource.rs
@@ -23,12 +23,12 @@ fn test(f: int) -> test {
 }
 
 fn main() {
-    let p = core::oldcomm::Port();
-    let c = core::oldcomm::Chan(&p);
+    let p = ::core::oldcomm::Port();
+    let c = ::core::oldcomm::Chan(&p);
 
     do task::spawn() {
-        let p = core::oldcomm::Port();
-        c.send(core::oldcomm::Chan(&p));
+        let p = ::core::oldcomm::Port();
+        c.send(::core::oldcomm::Chan(&p));
 
         let _r = p.recv();
     }

diff --git a/src/test/run-pass/static-fn-inline-xc.rs b/src/test/run-pass/static-fn-inline-xc.rs
index aa19fa560405ad03b825eb50e900addaa688e0c0..d67f327370399014439b0e06e80f369d5f4c1ee5 100644 (file)
--- a/src/test/run-pass/static-fn-inline-xc.rs
+++ b/src/test/run-pass/static-fn-inline-xc.rs
@@ -13,7 +13,7 @@
 
 extern mod mycore(name ="static_fn_inline_xc_aux");
 
-use mycore::num;
+use my::core::num;
 
 fn main() {
     let _1:float = num::Num2::from_int2(1i);

diff --git a/src/test/run-pass/static-fn-trait-xc.rs b/src/test/run-pass/static-fn-trait-xc.rs
index eb465ecff32a670d2b8a1a4b857eb184e91f29ca..8c643fb145a97fd41259c2ba19bb4d2c0306b1a7 100644 (file)
--- a/src/test/run-pass/static-fn-trait-xc.rs
+++ b/src/test/run-pass/static-fn-trait-xc.rs
@@ -3,7 +3,7 @@
 
 extern mod mycore(name ="static_fn_trait_xc_aux");
 
-use mycore::num;
+use my::core::num;
 
 fn main() {
     let _1:float = num::Num2::from_int2(1i);

diff --git a/src/test/run-pass/task-comm.rs b/src/test/run-pass/task-comm.rs
index d95f4af791c654d8fda8f67936b573330cdc6f76..311da9762b3c796947506cf3dc06def0b0ee2d21 100644 (file)
--- a/src/test/run-pass/task-comm.rs
+++ b/src/test/run-pass/task-comm.rs
@@ -17,12 +17,12 @@ fn main() {
     test06();
 }
 
-fn test00_start(ch: core::oldcomm::Chan<int>, message: int, count: int) {
+fn test00_start(ch: ::core::oldcomm::Chan<int>, message: int, count: int) {
     debug!("Starting test00_start");
     let mut i: int = 0;
     while i < count {
         debug!("Sending Message");
-        core::oldcomm::send(ch, message + 0);
+        ::core::oldcomm::send(ch, message + 0);
         i = i + 1;
     }
     debug!("Ending test00_start");
@@ -33,8 +33,8 @@ fn test00() {
     let number_of_messages: int = 4;
     debug!("Creating tasks");
 
-    let po = core::oldcomm::Port();
-    let ch = core::oldcomm::Chan(&po);
+    let po = ::core::oldcomm::Port();
+    let ch = ::core::oldcomm::Chan(&po);
 
     let mut i: int = 0;
 
@@ -50,7 +50,7 @@ fn test00() {
     let mut sum: int = 0;
     for results.each |r| {
         i = 0;
-        while i < number_of_messages { sum += core::oldcomm::recv(po); i = i + 1; }
+        while i < number_of_messages { sum += ::core::oldcomm::recv(po); i = i + 1; }
     }
 
     for results.each |r| { r.recv(); }
@@ -63,19 +63,19 @@ fn test00() {
 }
 
 fn test01() {
-    let p = core::oldcomm::Port();
+    let p = ::core::oldcomm::Port();
     debug!("Reading from a port that is never written to.");
-    let value: int = core::oldcomm::recv(p);
+    let value: int = ::core::oldcomm::recv(p);
     log(debug, value);
 }
 
 fn test02() {
-    let p = core::oldcomm::Port();
-    let c = core::oldcomm::Chan(&p);
+    let p = ::core::oldcomm::Port();
+    let c = ::core::oldcomm::Chan(&p);
     debug!("Writing to a local task channel.");
-    core::oldcomm::send(c, 42);
+    ::core::oldcomm::send(c, 42);
     debug!("Reading from a local task port.");
-    let value: int = core::oldcomm::recv(p);
+    let value: int = ::core::oldcomm::recv(p);
     log(debug, value);
 }
 
@@ -93,22 +93,22 @@ fn test04() {
     debug!("Finishing up.");
 }
 
-fn test05_start(ch: core::oldcomm::Chan<int>) {
-    core::oldcomm::send(ch, 10);
-    core::oldcomm::send(ch, 20);
-    core::oldcomm::send(ch, 30);
-    core::oldcomm::send(ch, 30);
-    core::oldcomm::send(ch, 30);
+fn test05_start(ch: ::core::oldcomm::Chan<int>) {
+    ::core::oldcomm::send(ch, 10);
+    ::core::oldcomm::send(ch, 20);
+    ::core::oldcomm::send(ch, 30);
+    ::core::oldcomm::send(ch, 30);
+    ::core::oldcomm::send(ch, 30);
 }
 
 fn test05() {
-    let po = core::oldcomm::Port();
-    let ch = core::oldcomm::Chan(&po);
+    let po = ::core::oldcomm::Port();
+    let ch = ::core::oldcomm::Chan(&po);
     task::spawn(|| test05_start(ch) );
     let mut value: int;
-    value = core::oldcomm::recv(po);
-    value = core::oldcomm::recv(po);
-    value = core::oldcomm::recv(po);
+    value = ::core::oldcomm::recv(po);
+    value = ::core::oldcomm::recv(po);
+    value = ::core::oldcomm::recv(po);
     log(debug, value);
 }
 

diff --git a/src/test/run-pass/trait-static-method-overwriting.rs b/src/test/run-pass/trait-static-method-overwriting.rs
index c2751145e6d0e542f8948e161309df738b8a62f2..d8a8fc26d7fdfb456955b28988b9f70f2e224cdd 100644 (file)
--- a/src/test/run-pass/trait-static-method-overwriting.rs
+++ b/src/test/run-pass/trait-static-method-overwriting.rs
@@ -1,3 +1,5 @@
+// xfail-fast
+
 // Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.

diff --git a/src/test/run-pass/trait-to-str.rs b/src/test/run-pass/trait-to-str.rs
index 43cafa49b4e19310548e247d8719cba6dd5a8b60..77384bdd27ae12c4edda08c2025f60b1e28df57f 100644 (file)
--- a/src/test/run-pass/trait-to-str.rs
+++ b/src/test/run-pass/trait-to-str.rs
@@ -14,7 +14,7 @@
 
 extern mod core;
 
-use core::{str, int, vec};
+use ::core::{str, int, vec};
 
 trait to_str {
     fn to_str() -> ~str;

diff --git a/src/test/run-pass/use.rs b/src/test/run-pass/use.rs
index 0afac13303d8bcfbd43ea86679313df1af434230..23202243b4504c4ec2d1e8604d37cd5828e798e2 100644 (file)
--- a/src/test/run-pass/use.rs
+++ b/src/test/run-pass/use.rs
@@ -16,12 +16,12 @@
 extern mod bar(name = "core", vers = "0.6");
 
 
-use core::str;
+use ::core::str;
 use x = zed::str;
 mod baz {
     #[legacy_exports];
     use bar::str;
-    use x = core::str;
+    use x = ::core::str;
 }
 
 fn main() { }

diff --git a/src/test/run-pass/vec-matching-autoslice.rs b/src/test/run-pass/vec-matching-autoslice.rs
index badb0245b8174f5e9ed3b5858064348f011f54d7..298253b8825d37abcd93a0ac03071611b5bc6104 100644 (file)
--- a/src/test/run-pass/vec-matching-autoslice.rs
+++ b/src/test/run-pass/vec-matching-autoslice.rs
@@ -1,22 +1,22 @@
 fn main() {
     let x = @[1, 2, 3];
     match x {
-        [2, .._] => core::util::unreachable(),
+        [2, .._] => ::core::util::unreachable(),
         [1, ..tail] => {
             assert tail == [2, 3];
         }
-        [_] => core::util::unreachable(),
-        [] => core::util::unreachable()
+        [_] => ::core::util::unreachable(),
+        [] => ::core::util::unreachable()
     }
 
     let y = (~[(1, true), (2, false)], 0.5);
     match y {
-        ([_, _, _], 0.5) => core::util::unreachable(),
+        ([_, _, _], 0.5) => ::core::util::unreachable(),
         ([(1, a), (b, false), ..tail], _) => {
             assert a == true;
             assert b == 2;
             assert tail.is_empty();
         }
-        ([..tail], _) => core::util::unreachable()
+        ([..tail], _) => ::core::util::unreachable()
     }
 }

diff --git a/src/test/run-pass/vec-matching-legal-tail-element-borrow.rs b/src/test/run-pass/vec-matching-legal-tail-element-borrow.rs
index ea21408788e880d5bf1b25b941a32c0c3710f3e7..6b005bf0e1218fe7781833f80e83490f40b3a5b7 100644 (file)
--- a/src/test/run-pass/vec-matching-legal-tail-element-borrow.rs
+++ b/src/test/run-pass/vec-matching-legal-tail-element-borrow.rs
@@ -3,7 +3,7 @@ fn main() {
     if !x.is_empty() {
         let el = match x {
             [1, ..ref tail] => &tail[0], 
-            _ => core::util::unreachable()
+            _ => ::core::util::unreachable()
         };
         io::println(fmt!("%d", *el));
     }

diff --git a/src/test/run-pass/vec-matching.rs b/src/test/run-pass/vec-matching.rs
index a3840c9f561f82aab77648a81b68a1777390f74d..687788d8ce83d1d944c4646e875b649d54e243b8 100644 (file)
--- a/src/test/run-pass/vec-matching.rs
+++ b/src/test/run-pass/vec-matching.rs
@@ -14,7 +14,7 @@ fn main() {
     let x = [1, 2, 3, 4, 5];
     match x {
         [a, b, c, d, e, f] => {
-            core::util::unreachable();
+            ::core::util::unreachable();
         }
         [a, b, c, d, e] => {
             assert a == 1;
@@ -24,7 +24,7 @@ fn main() {
             assert e == 5;
         }
         _ => {
-            core::util::unreachable();
+            ::core::util::unreachable();
         }
     }
 

diff --git a/src/test/run-pass/vec-tail-matching.rs b/src/test/run-pass/vec-tail-matching.rs
index e2b68a11776e1044cfcc929dfa2f39b308c12193..8a50d7b1643ac21bfbcb1e420b94c94d37fa9c93 100644 (file)
--- a/src/test/run-pass/vec-tail-matching.rs
+++ b/src/test/run-pass/vec-tail-matching.rs
@@ -17,19 +17,19 @@ fn main() {
 
             match tail {
                 [Foo { _ }, _, Foo { _ }, ..tail] => {
-                    core::util::unreachable();
+                    ::core::util::unreachable();
                 }
                 [Foo { string: a }, Foo { string: b }] => {
                     assert a == ~"bar";
                     assert b == ~"baz";
                 }
                 _ => {
-                    core::util::unreachable();
+                    ::core::util::unreachable();
                 }
             }
         }
         _ => {
-            core::util::unreachable();
+            ::core::util::unreachable();
         }
     }
 }