librustc: Make unqualified identifier searches terminate at the nearest ...

src/libcargo/pgp.rs

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 use core::os;
+use core::path::Path;
 use core::run;
 
 fn gpgv(args: ~[~str]) -> { status: int, out: ~str, err: ~str } {

src/libcore/at_vec.rs

@@ -15,8 +15,10 @@
 #[forbid(deprecated_pattern)];
 
 use cast::transmute;
+use kinds::Copy;
 use iter;
 use libc;
+use option::Option;
 use ptr::addr_of;
 use sys;
 use uint;
@@ -150,6 +152,10 @@ pub pure fn from_elem<T: Copy>(n_elts: uint, t: T) -> @[T] {
 
 #[cfg(notest)]
 pub mod traits {
+    use at_vec::append;
+    use kinds::Copy;
+    use ops::Add;
+
     pub impl<T: Copy> @[T] : Add<&[const T],@[T]> {
         #[inline(always)]
         pure fn add(&self, rhs: & &self/[const T]) -> @[T] {
@@ -162,8 +168,10 @@ pub mod traits {
 pub mod traits {}
 
 pub mod raw {
-    use at_vec::{rusti, rustrt};
+    use at_vec::{capacity, rusti, rustrt};
+    use cast::transmute;
     use libc;
+    use ptr::addr_of;
     use ptr;
     use sys;
     use uint;

src/libcore/bool.rs

@@ -19,6 +19,7 @@
 use bool;
 use cmp;
 use cmp::Eq;
+use option::{None, Option, Some};
 
 /// Negation / inverse
 pub pure fn not(v: bool) -> bool { !v }

src/libcore/cast.rs

@@ -108,6 +108,8 @@ pub unsafe fn copy_lifetime_vec<S,T>(_ptr: &a/[S], ptr: &T) -> &a/T {
 
 #[cfg(test)]
 pub mod tests {
+    use cast::{bump_box_refcount, reinterpret_cast, transmute};
+
     #[test]
     pub fn test_reinterpret_cast() {
         assert 1u == unsafe { reinterpret_cast(&1) };

src/libcore/char.rs

@@ -16,6 +16,7 @@
 
 use char;
 use cmp::Eq;
+use option::{None, Option, Some};
 use str;
 use u32;
 use uint;

src/libcore/condition.rs

@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use prelude::*;
 use task;
 
 // helper for transmutation, shown below.

src/libcore/core.rc

@@ -53,6 +53,9 @@ Implicitly, all crates behave as if they included the following prologue:
 #[warn(vecs_implicitly_copyable)];
 #[deny(non_camel_case_types)];
 
+/* The Prelude. */
+
+pub mod prelude;
 
 /* Primitive types */
 
@@ -243,6 +246,8 @@ pub mod core {
 
     pub use cmp;
     pub use condition;
+    pub use option;
+    pub use kinds;
 }
 
 

src/libcore/dlist.rs

@@ -22,7 +22,9 @@ Do not use ==, !=, <, etc on doubly-linked lists -- it may not terminate.
 #[forbid(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
+use kinds::Copy;
 use managed;
+use option::{None, Option, Some};
 use option;
 use vec;
 
@@ -94,13 +96,13 @@ impl<T> DListNode<T> {
 }
 
 /// Creates a new dlist node with the given data.
-pure fn new_dlist_node<T>(data: T) -> DListNode<T> {
+pub pure fn new_dlist_node<T>(data: T) -> DListNode<T> {
     DListNode(@{data: move data, mut linked: false,
                  mut prev: None, mut next: None})
 }
 
 /// Creates a new, empty dlist.
-pure fn DList<T>() -> DList<T> {
+pub pure fn DList<T>() -> DList<T> {
     DList_(@{mut size: 0, mut hd: None, mut tl: None})
 }
 
@@ -120,7 +122,7 @@ pub fn from_vec<T: Copy>(vec: &[T]) -> DList<T> {
 
 /// Produce a list from a list of lists, leaving no elements behind in the
 /// input. O(number of sub-lists).
-fn concat<T>(lists: DList<DList<T>>) -> DList<T> {
+pub fn concat<T>(lists: DList<DList<T>>) -> DList<T> {
     let result = DList();
     while !lists.is_empty() {
         result.append(lists.pop().get());
@@ -474,7 +476,9 @@ impl<T: Copy> DList<T> {
 mod tests {
     #[legacy_exports];
 
+    use dlist::{DList, concat, from_vec, new_dlist_node};
     use iter;
+    use option::{None, Some};
     use vec;
 
     #[test]

src/libcore/dvec.rs

@@ -25,6 +25,7 @@ Note that recursive use is not permitted.
 
 use cast;
 use cast::reinterpret_cast;
+use prelude::*;
 use ptr::null;
 use vec;
 

src/libcore/either.rs

@@ -14,10 +14,11 @@
 
 //! A type that represents one of two alternatives
 
-use cmp;
 use cmp::Eq;
-use result;
+use cmp;
+use kinds::Copy;
 use result::Result;
+use result;
 use vec;
 
 /// The either type

src/libcore/extfmt.rs

@@ -82,6 +82,7 @@ debug!("hello, %s!", "world");
 
 use cmp::Eq;
 use option::{Some, None};
+use prelude::*;
 use str;
 
 /*
@@ -99,6 +100,7 @@ use str;
 #[doc(hidden)]
 pub mod ct {
     use char;
+    use prelude::*;
     use str;
     use vec;
 

src/libcore/float.rs

@@ -31,6 +31,7 @@ use cmp;
 use f64;
 use num;
 use num::Num::from_int;
+use option::{None, Option, Some};
 use str;
 use uint;
 

src/libcore/gc.rs

@@ -42,6 +42,7 @@ with destructors.
 use cast;
 use io;
 use libc::{size_t, uintptr_t};
+use option::{None, Option, Some};
 use ptr;
 use send_map::linear::LinearMap;
 use stackwalk;

src/libcore/int-template.rs

@@ -21,6 +21,7 @@ use from_str::FromStr;
 use iter;
 use num;
 use num::Num::from_int;
+use prelude::*;
 use str;
 use uint;
 use vec;

src/libcore/int-template/int.rs

@@ -50,8 +50,8 @@ mod inst {
 
     #[test]
     fn test_overflows() {
-        assert (max_value > 0);
-        assert (min_value <= 0);
-        assert (min_value + max_value + 1 == 0);
+        assert (::int::max_value > 0);
+        assert (::int::min_value <= 0);
+        assert (::int::min_value + ::int::max_value + 1 == 0);
     }
 }

src/libcore/io.rs

@@ -28,14 +28,15 @@ use libc::consts::os::posix88::*;
 use libc::consts::os::extra::*;
 use option;
 use os;
+use prelude::*;
 use ptr;
 use result;
 use str;
 use uint;
 use vec;
 
 #[allow(non_camel_case_types)] // not sure what to do about this
-type fd_t = c_int;
+pub type fd_t = c_int;
 
 #[abi = "cdecl"]
 extern mod rustrt {
@@ -452,12 +453,12 @@ impl<T: Reader, C> {base: T, cleanup: C}: Reader {
     fn tell(&self) -> uint { self.base.tell() }
 }
 
-struct FILERes {
+pub struct FILERes {
     f: *libc::FILE,
     drop { libc::fclose(self.f); }
 }
 
-fn FILERes(f: *libc::FILE) -> FILERes {
+pub fn FILERes(f: *libc::FILE) -> FILERes {
     FILERes {
         f: f
     }
@@ -629,12 +630,12 @@ impl fd_t: Writer {
     }
 }
 
-struct FdRes {
+pub struct FdRes {
     fd: fd_t,
     drop { libc::close(self.fd); }
 }
 
-fn FdRes(fd: fd_t) -> FdRes {
+pub fn FdRes(fd: fd_t) -> FdRes {
     FdRes {
         fd: fd
     }
@@ -1028,7 +1029,10 @@ pub fn read_whole_file(file: &Path) -> Result<~[u8], ~str> {
 // fsync related
 
 pub mod fsync {
+    use io::{FILERes, FdRes, fd_t};
+    use kinds::Copy;
     use libc;
+    use option::Option;
     use option;
     use os;
 
@@ -1113,8 +1117,11 @@ pub mod fsync {
 
 #[cfg(test)]
 mod tests {
+    use debug;
     use i32;
+    use io::{BytesWriter, SeekCur, SeekEnd, SeekSet};
     use io;
+    use path::Path;
     use result;
     use str;
     use u64;

src/libcore/iter-trait.rs

@@ -16,7 +16,10 @@
 #[forbid(deprecated_pattern)];
 
 use cmp::{Eq, Ord};
+use iter::BaseIter;
 use iter;
+use kinds::Copy;
+use option::Option;
 
 use self::inst::{IMPL_T, EACH, SIZE_HINT};
 

src/libcore/iter-trait/dlist.rs

@@ -11,6 +11,7 @@
 mod inst {
     use dlist;
     use managed;
+    use option::{Option, Some};
     use option;
 
     #[allow(non_camel_case_types)]

src/libcore/iter-trait/dvec.rs

@@ -10,6 +10,7 @@
 
 mod inst {
     use dvec;
+    use option::{Option, Some};
 
     #[allow(non_camel_case_types)]
     pub type IMPL_T<A> = dvec::DVec<A>;

src/libcore/iter-trait/option.rs

@@ -9,6 +9,8 @@
 // except according to those terms.
 
 mod inst {
+    use option::{None, Option, Some};
+
     #[allow(non_camel_case_types)]
     pub type IMPL_T<A> = Option<A>;
 
@@ -25,4 +27,4 @@ mod inst {
             Some(_) => Some(1)
         }
     }
-}
+}

src/libcore/iter.rs

@@ -18,6 +18,8 @@ The iteration traits and common implementation
 #[forbid(deprecated_pattern)];
 
 use cmp::{Eq, Ord};
+use kinds::Copy;
+use option::{None, Option, Some};
 use vec;
 
 /// A function used to initialize the elements of a sequence