librustc: Terminate name searches at the nearest module scope for paths ...

src/driver/driver.rs

@@ -12,18 +12,18 @@
 extern mod core(vers = "0.5");
 
 #[cfg(cargo)]
-extern mod self(name = "cargo", vers = "0.5");
+extern mod this(name = "cargo", vers = "0.5");
 
 #[cfg(fuzzer)]
-extern mod self(name = "fuzzer", vers = "0.5");
+extern mod this(name = "fuzzer", vers = "0.5");
 
 #[cfg(rustdoc)]
-extern mod self(name = "rustdoc", vers = "0.5");
+extern mod this(name = "rustdoc", vers = "0.5");
 
 #[cfg(rusti)]
-extern mod self(name = "rusti", vers = "0.5");
+extern mod this(name = "rusti", vers = "0.5");
 
 #[cfg(rustc)]
-extern mod self(name = "rustc", vers = "0.5");
+extern mod this(name = "rustc", vers = "0.5");
 
-fn main() { self::main() }
+fn main() { this::main() }

src/libcargo/pgp.rs

@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use core::os;
+use core::run;
+
 fn gpgv(args: ~[~str]) -> { status: int, out: ~str, err: ~str } {
     return run::program_output(~"gpgv", args);
 }

src/libcore/at_vec.rs

@@ -15,21 +15,26 @@
 #[forbid(deprecated_pattern)];
 
 use cast::transmute;
+use iter;
+use libc;
 use ptr::addr_of;
+use sys;
+use uint;
+use vec;
 
 /// Code for dealing with @-vectors. This is pretty incomplete, and
 /// contains a bunch of duplication from the code for ~-vectors.
 
 #[abi = "cdecl"]
-extern mod rustrt {
+pub extern mod rustrt {
     #[legacy_exports];
     fn vec_reserve_shared_actual(++t: *sys::TypeDesc,
                                  ++v: **vec::raw::VecRepr,
                                  ++n: libc::size_t);
 }
 
 #[abi = "rust-intrinsic"]
-extern mod rusti {
+pub extern mod rusti {
     #[legacy_exports];
     fn move_val_init<T>(dst: &mut T, -src: T);
 }
@@ -157,6 +162,13 @@ pub mod traits {
 pub mod traits {}
 
 pub mod raw {
+    use at_vec::{rusti, rustrt};
+    use libc;
+    use ptr;
+    use sys;
+    use uint;
+    use vec;
+
     pub type VecRepr = vec::raw::VecRepr;
     pub type SliceRepr = vec::raw::SliceRepr;
 

src/libcore/bool.rs

@@ -16,6 +16,7 @@
 
 //! Boolean logic
 
+use cmp;
 use cmp::Eq;
 
 /// Negation / inverse

src/libcore/char.rs

@@ -15,6 +15,10 @@
 #[forbid(deprecated_pattern)];
 
 use cmp::Eq;
+use str;
+use u32;
+use uint;
+use unicode;
 
 /*
     Lu  Uppercase_Letter    an uppercase letter

src/libcore/condition.rs

@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use task;
+
 // helper for transmutation, shown below.
 type RustClosure = (int,int);
 struct Handler<T, U:Copy> {

src/libcore/core.rc

@@ -235,7 +235,7 @@ mod stackwalk;
 // 'core' so that macro-expanded references to core::error and such
 // can be resolved within libcore.
 #[doc(hidden)] // FIXME #3538
-mod core {
+pub mod core {
     pub const error : u32 = 1_u32;
     pub const warn : u32 = 2_u32;
     pub const info : u32 = 3_u32;

src/libcore/dlist.rs

@@ -22,6 +22,10 @@ Do not use ==, !=, <, etc on doubly-linked lists -- it may not terminate.
 #[forbid(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
+use managed;
+use option;
+use vec;
+
 type DListLink<T> = Option<DListNode<T>>;
 
 enum DListNode<T> = @{

src/libcore/dvec.rs

@@ -23,8 +23,10 @@ Note that recursive use is not permitted.
 #[forbid(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
+use cast;
 use cast::reinterpret_cast;
 use ptr::null;
+use vec;
 
 /**
  * A growable, modifiable vector type that accumulates elements into a

src/libcore/either.rs

@@ -14,8 +14,11 @@
 
 //! A type that represents one of two alternatives
 
+use cmp;
 use cmp::Eq;
+use result;
 use result::Result;
+use vec;
 
 /// The either type
 #[deriving_eq]

src/libcore/extfmt.rs

@@ -82,7 +82,7 @@ debug!("hello, %s!", "world");
 
 use cmp::Eq;
 use option::{Some, None};
-
+use str;
 
 /*
  * We have a 'ct' (compile-time) module that parses format strings into a
@@ -98,6 +98,10 @@ use option::{Some, None};
 // Functions used by the fmt extension at compile time
 #[doc(hidden)]
 pub mod ct {
+    use char;
+    use str;
+    use vec;
+
     pub enum Signedness { Signed, Unsigned, }
     pub enum Caseness { CaseUpper, CaseLower, }
     pub enum Ty {
@@ -332,6 +336,12 @@ pub mod ct {
 // implement it 0this way, I think.
 #[doc(hidden)]
 pub mod rt {
+    use float;
+    use str;
+    use sys;
+    use uint;
+    use vec;
+
     pub const flag_none : u32 = 0u32;
     pub const flag_left_justify   : u32 = 0b00000000000001u32;
     pub const flag_left_zero_pad  : u32 = 0b00000000000010u32;

src/libcore/f32.rs

@@ -14,6 +14,9 @@
 
 //! Operations and constants for `f32`
 
+use cmp;
+use num;
+
 pub use cmath::c_float_utils::*;
 pub use cmath::c_float_targ_consts::*;
 

src/libcore/f64.rs

@@ -14,6 +14,11 @@
 
 //! Operations and constants for `f64`
 
+use cmath;
+use cmp;
+use libc;
+use num;
+
 pub use cmath::c_double_utils::*;
 pub use cmath::c_double_targ_consts::*;
 

src/libcore/flate.rs

@@ -18,7 +18,10 @@ Simple compression
 #[forbid(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
+use libc;
 use libc::{c_void, size_t, c_int};
+use ptr;
+use vec;
 
 extern mod rustrt {
     fn tdefl_compress_mem_to_heap(psrc_buf: *const c_void,

src/libcore/float.rs

@@ -26,6 +26,13 @@
 
 use m_float = f64;
 
+use cmp::{Eq, Ord};
+use f64;
+use num;
+use num::Num::from_int;
+use str;
+use uint;
+
 pub use f64::{add, sub, mul, div, rem, lt, le, eq, ne, ge, gt};
 pub use f64::logarithm;
 pub use f64::{acos, asin, atan2, cbrt, ceil, copysign, cosh, floor};
@@ -35,8 +42,6 @@ pub use f64::{lgamma, ln, log_radix, ln1p, log10, log2, ilog_radix};
 pub use f64::{modf, pow, round, sinh, tanh, tgamma, trunc};
 pub use f64::signbit;
 pub use f64::{j0, j1, jn, y0, y1, yn};
-use cmp::{Eq, Ord};
-use num::Num::from_int;
 
 pub const NaN: float = 0.0/0.0;
 

src/libcore/gc.rs

@@ -39,10 +39,15 @@ with destructors.
 #[forbid(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
-pub use stackwalk::Word;
-use libc::size_t;
-use libc::uintptr_t;
+use cast;
+use io;
+use libc::{size_t, uintptr_t};
+use ptr;
 use send_map::linear::LinearMap;
+use stackwalk;
+use sys;
+
+pub use stackwalk::Word;
 
 // Mirrors rust_stack.h stk_seg
 struct StackSegment {

src/libcore/hash.rs

@@ -23,9 +23,12 @@
  * CPRNG like rand::rng.
  */
 
-use io::Writer;
-use io::WriterUtil;
+use io;
+use io::{Writer, WriterUtil};
+use os;
 use to_bytes::IterBytes;
+use uint;
+use vec;
 
 /**
  * Types that can meaningfully be hashed should implement this.

src/libcore/int-template.rs

@@ -18,9 +18,15 @@ use T = inst::T;
 #[cfg(stage2)]
 use T = self::inst::T;
 
+use char;
 use cmp::{Eq, Ord};
 use from_str::FromStr;
+use iter;
+use num;
 use num::Num::from_int;
+use str;
+use uint;
+use vec;
 
 pub const bits : uint = inst::bits;
 pub const bytes : uint = (inst::bits / 8);

src/libcore/int-template/i16.rs

@@ -12,5 +12,5 @@
 
 mod inst {
     pub type T = i16;
-    pub const bits: uint = u16::bits;
-}
+    pub const bits: uint = ::u16::bits;
+}

src/libcore/int-template/i32.rs

@@ -12,5 +12,5 @@
 
 mod inst {
     pub type T = i32;
-    pub const bits: uint = u32::bits;
+    pub const bits: uint = ::u32::bits;
 }

src/libcore/int-template/i64.rs

@@ -12,5 +12,5 @@
 
 mod inst {
     pub type T = i64;
-    pub const bits: uint = u64::bits;
-}
+    pub const bits: uint = ::u64::bits;
+}

src/libcore/int-template/i8.rs

@@ -12,5 +12,5 @@
 
 mod inst {
     pub type T = i8;
-    pub const bits: uint = u8::bits;
-}
+    pub const bits: uint = ::u8::bits;
+}

src/libcore/int-template/int.rs

@@ -18,7 +18,7 @@ pub use self::inst::pow;
 
 mod inst {
     pub type T = int;
-    pub const bits: uint = uint::bits;
+    pub const bits: uint = ::uint::bits;
 
     /// Returns `base` raised to the power of `exponent`
     pub fn pow(base: int, exponent: uint) -> int {

src/libcore/io.rs

@@ -21,9 +21,18 @@ use result::Result;
 
 use cmp::Eq;
 use dvec::DVec;
+use int;
+use libc;
 use libc::{c_int, c_long, c_uint, c_void, size_t, ssize_t};
 use libc::consts::os::posix88::*;
 use libc::consts::os::extra::*;
+use option;
+use os;
+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;
@@ -1025,6 +1034,9 @@ pub fn read_whole_file(file: &Path) -> Result<~[u8], ~str> {
 // fsync related
 
 pub mod fsync {
+    use libc;
+    use option;
+    use os;
 
     pub enum Level {
         // whatever fsync does on that platform

src/libcore/iter-trait.rs

@@ -16,6 +16,7 @@
 #[forbid(deprecated_pattern)];
 
 use cmp::{Eq, Ord};
+use iter;
 
 #[cfg(stage0)]
 use inst::{IMPL_T, EACH, SIZE_HINT};

src/libcore/iter-trait/dlist.rs

@@ -9,6 +9,10 @@
 // except according to those terms.
 
 mod inst {
+    use dlist;
+    use managed;
+    use option;
+
     #[allow(non_camel_case_types)]
     pub type IMPL_T<A> = dlist::DList<A>;
 
@@ -45,4 +49,4 @@ mod inst {
     pub pure fn SIZE_HINT<A>(self: &IMPL_T<A>) -> Option<uint> {
         Some(self.len())
     }
-}
+}