---

yaml
---
r: 44941
b: refs/heads/master
c: 40e733a
h: refs/heads/master
i:
  44939: 773db88
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: cb4ab76e4a17e0efc6b506af15fd1df654c043ff
+refs/heads/master: 40e733a1509044a5dacc0012426879a664c7a146
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d9689399d091c3265f00434a69c551a61c28dc
 refs/heads/try: ef355f6332f83371e4acf04fc4eb940ab41d78d3

trunk/src/compiletest/common.rs

@@ -10,6 +10,8 @@
 
 use core::prelude::*;
 
+use cmp;
+
 #[deriving_eq]
 pub enum mode {
     mode_compile_fail,

trunk/src/compiletest/compiletest.rc

@@ -32,6 +32,7 @@ pub mod errors;
 use std::getopts;
 use std::test;
 
+use core::{result, either};
 use core::result::{Ok, Err};
 
 use common::config;

trunk/src/compiletest/errors.rs

@@ -10,6 +10,8 @@
 
 use core::prelude::*;
 
+use common::config;
+
 use core::io;
 use core::io::ReaderUtil;
 use core::str;

trunk/src/compiletest/procsrv.rs

@@ -13,11 +13,14 @@ use core::prelude::*;
 use core::io::{ReaderUtil, WriterUtil};
 use core::io;
 use core::libc::{c_int, pid_t};
+use core::libc;
 use core::os;
+use core::pipes;
 use core::run::spawn_process;
 use core::run;
 use core::str;
 use core::task;
+use core::vec;
 
 #[cfg(target_os = "win32")]
 fn target_env(lib_path: ~str, prog: ~str) -> ~[(~str,~str)] {

trunk/src/compiletest/runtest.rs

@@ -10,12 +10,14 @@
 
 use core::prelude::*;
 
+use common;
 use common::mode_run_pass;
 use common::mode_run_fail;
 use common::mode_compile_fail;
 use common::mode_pretty;
 use common::config;
 use errors;
+use header;
 use header::load_props;
 use header::TestProps;
 use procsrv;

trunk/src/compiletest/util.rs

@@ -10,10 +10,12 @@
 
 use core::prelude::*;
 
+use common;
 use common::config;
 
 use core::io;
 use core::os::getenv;
+use core::os;
 
 pub fn make_new_path(path: ~str) -> ~str {
 

trunk/src/libcore/bool.rs

@@ -11,8 +11,10 @@
 
 //! Boolean logic
 
+use bool;
+use cmp;
+use cmp::Eq;
 use option::{None, Option, Some};
-#[cfg(notest)] use cmp;
 
 /// Negation / inverse
 pub pure fn not(v: bool) -> bool { !v }
@@ -80,7 +82,7 @@ impl cmp::Eq for bool {
 #[test]
 pub fn test_bool_from_str() {
     do all_values |v| {
-        assert Some(v) == from_str(to_str(v))
+        assert Some(v) == from_str(bool::to_str(v))
     }
 }
 

trunk/src/libcore/char.rs

@@ -10,14 +10,14 @@
 
 //! Utilities for manipulating the char type
 
+use char;
+use cmp::Eq;
 use option::{None, Option, Some};
 use str;
 use u32;
 use uint;
 use unicode;
 
-#[cfg(notest)] use cmp::Eq;
-
 /*
     Lu  Uppercase_Letter    an uppercase letter
     Ll  Lowercase_Letter    a lowercase letter
@@ -305,8 +305,8 @@ fn test_to_digit() {
 
 #[test]
 fn test_is_ascii() {
-   assert str::all(~"banana", is_ascii);
-   assert ! str::all(~"ประเทศไทย中华Việt Nam", is_ascii);
+   assert str::all(~"banana", char::is_ascii);
+   assert ! str::all(~"ประเทศไทย中华Việt Nam", char::is_ascii);
 }
 
 #[test]

trunk/src/libcore/dvec.rs

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

trunk/src/libcore/either.rs

@@ -11,6 +11,7 @@
 //! A type that represents one of two alternatives
 
 use cmp::Eq;
+use cmp;
 use kinds::Copy;
 use result::Result;
 use result;

trunk/src/libcore/flate.rs

@@ -17,10 +17,9 @@ Simple compression
 use libc;
 use libc::{c_void, size_t, c_int};
 use ptr;
+use rand;
 use vec;
 
-#[cfg(test)] use rand;
-
 extern mod rustrt {
     unsafe fn tdefl_compress_mem_to_heap(psrc_buf: *const c_void,
                                          src_buf_len: size_t,

trunk/src/libcore/hash.rs

@@ -21,6 +21,7 @@
 
 use io;
 use io::{Writer, WriterUtil};
+use os;
 use to_bytes::IterBytes;
 use uint;
 use vec;

trunk/src/libcore/hashmap.rs

@@ -19,8 +19,11 @@ pub mod linear {
     use iter::BaseIter;
     use hash::Hash;
     use iter;
+    use kinds::Copy;
     use option::{None, Option, Some};
+    use option;
     use rand;
+    use to_bytes::IterBytes;
     use uint;
     use vec;
 

trunk/src/libcore/io.rs

@@ -16,11 +16,14 @@ Basic input/output
 
 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 prelude::*;
 use ptr;
@@ -75,6 +78,9 @@ pub trait ReaderUtil {
     /// Read len bytes into a new vec.
     fn read_bytes(&self, len: uint) -> ~[u8];
 
+    /// Read up until a specified character (which is not returned) or EOF.
+    fn read_until(&self, c: char) -> ~str;
+
     /// Read up until the first '\n' char (which is not returned), or EOF.
     fn read_line(&self) -> ~str;
 
@@ -178,16 +184,22 @@ impl<T:Reader> ReaderUtil for T {
         bytes
     }
 
-    fn read_line(&self) -> ~str {
+    fn read_until(&self, c: char) -> ~str {
         let mut bytes = ~[];
         loop {
             let ch = self.read_byte();
-            if ch == -1 || ch == 10 { break; }
+            if ch == -1 || ch == c as int {
+                break;
+            }
             bytes.push(ch as u8);
         }
         str::from_bytes(bytes)
     }
 
+    fn read_line(&self) -> ~str {
+        self.read_until('\n')
+    }
+
     fn read_chars(&self, n: uint) -> ~[char] {
         // returns the (consumed offset, n_req), appends characters to &chars
         fn chars_from_bytes<T:Reader>(bytes: &~[u8], chars: &mut ~[char])
@@ -259,12 +271,7 @@ impl<T:Reader> ReaderUtil for T {
     }
 
     fn read_c_str(&self) -> ~str {
-        let mut bytes: ~[u8] = ~[];
-        loop {
-            let ch = self.read_byte();
-            if ch < 1 { break; } else { bytes.push(ch as u8); }
-        }
-        str::from_bytes(bytes)
+        self.read_until(0 as char)
     }
 
     fn read_whole_stream(&self) -> ~[u8] {
@@ -712,9 +719,7 @@ pub fn mk_file_writer(path: &Path, flags: &[FileFlag])
     -> Result<Writer, ~str> {
 
     #[cfg(windows)]
-    fn wb() -> c_int {
-      (O_WRONLY | libc::consts::os::extra::O_BINARY) as c_int
-    }
+    fn wb() -> c_int { (O_WRONLY | O_BINARY) as c_int }
 
     #[cfg(unix)]
     fn wb() -> c_int { O_WRONLY as c_int }

trunk/src/libcore/iter-trait/dlist.rs

@@ -9,6 +9,8 @@
 // except according to those terms.
 
 mod inst {
+    use cast;
+    use dlist;
     use dlist::DList;
     use managed;
     use option::{Option, Some};

trunk/src/libcore/libc.rs

@@ -1007,6 +1007,7 @@ pub mod funcs {
 
     pub mod c95 {
         use libc::types::common::c95::{FILE, c_void, fpos_t};
+        use libc::types::common::posix88::dirent_t;
         use libc::types::os::arch::c95::{c_char, c_double, c_int, c_long};
         use libc::types::os::arch::c95::{c_uint, c_ulong, c_void, size_t};
 

trunk/src/libcore/logging.rs

@@ -10,7 +10,11 @@
 
 //! Logging
 
+use cast::transmute;
+use io;
 use libc;
+use repr;
+use vec;
 
 #[nolink]
 extern mod rustrt {
@@ -44,11 +48,6 @@ pub fn console_off() {
 #[cfg(notest)]
 #[lang="log_type"]
 pub fn log_type<T>(level: u32, object: &T) {
-    use cast::transmute;
-    use io;
-    use repr;
-    use vec;
-
     let bytes = do io::with_bytes_writer |writer| {
         repr::write_repr(writer, object);
     };

trunk/src/libcore/managed.rs

@@ -10,9 +10,12 @@
 
 //! Operations on managed box types
 
+use cast::transmute;
+use cmp::{Eq, Ord};
+use managed::raw::BoxRepr;
+use prelude::*;
 use ptr;
 
-#[cfg(notest)] use cmp::{Eq, Ord};
 
 pub mod raw {
 

trunk/src/libcore/nil.rs

@@ -14,7 +14,6 @@ Functions for the unit type.
 
 */
 
-#[cfg(notest)]
 use cmp::{Eq, Ord};
 
 #[cfg(notest)]

trunk/src/libcore/num/f32.rs

@@ -11,18 +11,17 @@
 //! Operations and constants for `f32`
 
 use cmath;
+use cmp;
 use libc::{c_float, c_int};
 use num::NumCast;
 use num::strconv;
 use num;
+use ops;
 use option::Option;
 use unstable::intrinsics::floorf32;
 use from_str;
 use to_str;
 
-#[cfg(notest)] use cmp;
-#[cfg(notest)] use ops;
-
 pub use cmath::c_float_targ_consts::*;
 
 macro_rules! delegate(

trunk/src/libcore/num/f64.rs

@@ -11,18 +11,18 @@
 //! Operations and constants for `f64`
 
 use cmath;
+use cmp;
 use libc::{c_double, c_int};
+use libc;
 use num::NumCast;
 use num::strconv;
 use num;
+use ops;
 use option::Option;
 use unstable::intrinsics::floorf64;
 use to_str;
 use from_str;
 
-#[cfg(notest)] use cmp;
-#[cfg(notest)] use ops;
-
 pub use cmath::c_double_targ_consts::*;
 pub use cmp::{min, max};
 

trunk/src/libcore/num/float.rs

@@ -20,17 +20,21 @@
 
 // PORT this must match in width according to architecture
 
+use m_float = f64;
+
+use cmp::{Eq, Ord};
+use cmp;
 use f64;
 use num::NumCast;
 use num::strconv;
 use num;
+use ops;
 use option::{None, Option, Some};
+use str;
+use uint;
 use to_str;
 use from_str;
 
-#[cfg(notest)] use cmp::{Eq, Ord};
-#[cfg(notest)] use ops;
-
 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};