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

Author: pcwalton

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;
 }

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);
 }

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);
 }

src/test/run-pass/basic.rs

@@ -10,15 +10,15 @@
 // 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");
         debug!("task a");
         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);
 }

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;

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);
     }

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()

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);
 }

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) {

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,