Remove the crate language

src/compiletest/compiletest.rc

@@ -26,6 +26,198 @@ mod common;
 #[legacy_exports]
 mod errors;
 
+use std::getopts;
+use std::test;
+
+use core::result;
+use result::{Ok, Err};
+
+use common::config;
+use common::mode_run_pass;
+use common::mode_run_fail;
+use common::mode_compile_fail;
+use common::mode_pretty;
+use common::mode;
+use util::logv;
+
+fn main() {
+    let args = os::args();
+    let config = parse_config(args);
+    log_config(config);
+    run_tests(config);
+}
+
+fn parse_config(args: ~[~str]) -> config {
+    let opts =
+        ~[getopts::reqopt(~"compile-lib-path"),
+          getopts::reqopt(~"run-lib-path"),
+          getopts::reqopt(~"rustc-path"), getopts::reqopt(~"src-base"),
+          getopts::reqopt(~"build-base"), getopts::reqopt(~"aux-base"),
+          getopts::reqopt(~"stage-id"),
+          getopts::reqopt(~"mode"), getopts::optflag(~"ignored"),
+          getopts::optopt(~"runtool"), getopts::optopt(~"rustcflags"),
+          getopts::optflag(~"verbose"),
+          getopts::optopt(~"logfile"),
+          getopts::optflag(~"jit")];
+
+    assert (vec::is_not_empty(args));
+    let args_ = vec::tail(args);
+    let matches =
+        match getopts::getopts(args_, opts) {
+          Ok(m) => m,
+          Err(f) => fail getopts::fail_str(f)
+        };
+
+    fn opt_path(m: getopts::Matches, nm: ~str) -> Path {
+        Path(getopts::opt_str(m, nm))
+    }
+
+    return {compile_lib_path: getopts::opt_str(matches, ~"compile-lib-path"),
+         run_lib_path: getopts::opt_str(matches, ~"run-lib-path"),
+         rustc_path: opt_path(matches, ~"rustc-path"),
+         src_base: opt_path(matches, ~"src-base"),
+         build_base: opt_path(matches, ~"build-base"),
+         aux_base: opt_path(matches, ~"aux-base"),
+         stage_id: getopts::opt_str(matches, ~"stage-id"),
+         mode: str_mode(getopts::opt_str(matches, ~"mode")),
+         run_ignored: getopts::opt_present(matches, ~"ignored"),
+         filter:
+             if vec::len(matches.free) > 0u {
+                 option::Some(matches.free[0])
+             } else { option::None },
+         logfile: option::map(&getopts::opt_maybe_str(matches,
+                                                     ~"logfile"),
+                              |s| Path(*s)),
+         runtool: getopts::opt_maybe_str(matches, ~"runtool"),
+         rustcflags: getopts::opt_maybe_str(matches, ~"rustcflags"),
+         jit: getopts::opt_present(matches, ~"jit"),
+         verbose: getopts::opt_present(matches, ~"verbose")};
+}
+
+fn log_config(config: config) {
+    let c = config;
+    logv(c, fmt!("configuration:"));
+    logv(c, fmt!("compile_lib_path: %s", config.compile_lib_path));
+    logv(c, fmt!("run_lib_path: %s", config.run_lib_path));
+    logv(c, fmt!("rustc_path: %s", config.rustc_path.to_str()));
+    logv(c, fmt!("src_base: %s", config.src_base.to_str()));
+    logv(c, fmt!("build_base: %s", config.build_base.to_str()));
+    logv(c, fmt!("stage_id: %s", config.stage_id));
+    logv(c, fmt!("mode: %s", mode_str(config.mode)));
+    logv(c, fmt!("run_ignored: %b", config.run_ignored));
+    logv(c, fmt!("filter: %s", opt_str(config.filter)));
+    logv(c, fmt!("runtool: %s", opt_str(config.runtool)));
+    logv(c, fmt!("rustcflags: %s", opt_str(config.rustcflags)));
+    logv(c, fmt!("jit: %b", config.jit));
+    logv(c, fmt!("verbose: %b", config.verbose));
+    logv(c, fmt!("\n"));
+}
+
+fn opt_str(maybestr: Option<~str>) -> ~str {
+    match maybestr { option::Some(s) => s, option::None => ~"(none)" }
+}
+
+fn str_opt(maybestr: ~str) -> Option<~str> {
+    if maybestr != ~"(none)" { option::Some(maybestr) } else { option::None }
+}
+
+fn str_mode(s: ~str) -> mode {
+    match s {
+      ~"compile-fail" => mode_compile_fail,
+      ~"run-fail" => mode_run_fail,
+      ~"run-pass" => mode_run_pass,
+      ~"pretty" => mode_pretty,
+      _ => fail ~"invalid mode"
+    }
+}
+
+fn mode_str(mode: mode) -> ~str {
+    match mode {
+      mode_compile_fail => ~"compile-fail",
+      mode_run_fail => ~"run-fail",
+      mode_run_pass => ~"run-pass",
+      mode_pretty => ~"pretty"
+    }
+}
+
+fn run_tests(config: config) {
+    let opts = test_opts(config);
+    let tests = make_tests(config);
+    let res = test::run_tests_console(&opts, tests);
+    if !res { fail ~"Some tests failed"; }
+}
+
+fn test_opts(config: config) -> test::TestOpts {
+    {filter:
+         match config.filter {
+           option::Some(s) => option::Some(s),
+           option::None => option::None
+         },
+     run_ignored: config.run_ignored,
+     logfile:
+         match config.logfile {
+           option::Some(s) => option::Some(s.to_str()),
+           option::None => option::None
+         }
+    }
+}
+
+fn make_tests(config: config) -> ~[test::TestDesc] {
+    debug!("making tests from %s",
+           config.src_base.to_str());
+    let mut tests = ~[];
+    for os::list_dir_path(&config.src_base).each |file| {
+        let file = copy *file;
+        debug!("inspecting file %s", file.to_str());
+        if is_test(config, file) {
+            tests.push(make_test(config, file))
+        }
+    }
+    move tests
+}
+
+fn is_test(config: config, testfile: &Path) -> bool {
+    // Pretty-printer does not work with .rc files yet
+    let valid_extensions =
+        match config.mode {
+          mode_pretty => ~[~".rs"],
+          _ => ~[~".rc", ~".rs"]
+        };
+    let invalid_prefixes = ~[~".", ~"#", ~"~"];
+    let name = testfile.filename().get();
+
+    let mut valid = false;
+
+    for valid_extensions.each |ext| {
+        if str::ends_with(name, *ext) { valid = true; }
+    }
+
+    for invalid_prefixes.each |pre| {
+        if str::starts_with(name, *pre) { valid = false; }
+    }
+
+    return valid;
+}
+
+fn make_test(config: config, testfile: &Path) ->
+   test::TestDesc {
+    {
+        name: make_test_name(config, testfile),
+        testfn: make_test_closure(config, testfile),
+        ignore: header::is_test_ignored(config, testfile),
+        should_fail: false
+    }
+}
+
+fn make_test_name(config: config, testfile: &Path) -> ~str {
+    fmt!("[%s] %s", mode_str(config.mode), testfile.to_str())
+}
+
+fn make_test_closure(config: config, testfile: &Path) -> test::TestFn {
+    let testfile = testfile.to_str();
+    fn~() { runtest::run(config, testfile) }
+}
+
 // Local Variables:
 // fill-column: 78;
 // indent-tabs-mode: nil

src/compiletest/compiletest.rs

-use std::getopts;
-use std::test;
-
-use core::result;
-use result::{Ok, Err};
-
-use common::config;
-use common::mode_run_pass;
-use common::mode_run_fail;
-use common::mode_compile_fail;
-use common::mode_pretty;
-use common::mode;
-use util::logv;
-
-fn main() {
-    let args = os::args();
-    let config = parse_config(args);
-    log_config(config);
-    run_tests(config);
-}
-
-fn parse_config(args: ~[~str]) -> config {
-    let opts =
-        ~[getopts::reqopt(~"compile-lib-path"),
-          getopts::reqopt(~"run-lib-path"),
-          getopts::reqopt(~"rustc-path"), getopts::reqopt(~"src-base"),
-          getopts::reqopt(~"build-base"), getopts::reqopt(~"aux-base"),
-          getopts::reqopt(~"stage-id"),
-          getopts::reqopt(~"mode"), getopts::optflag(~"ignored"),
-          getopts::optopt(~"runtool"), getopts::optopt(~"rustcflags"),
-          getopts::optflag(~"verbose"),
-          getopts::optopt(~"logfile"),
-          getopts::optflag(~"jit")];
-
-    assert (vec::is_not_empty(args));
-    let args_ = vec::tail(args);
-    let matches =
-        match getopts::getopts(args_, opts) {
-          Ok(m) => m,
-          Err(f) => fail getopts::fail_str(f)
-        };
-
-    fn opt_path(m: getopts::Matches, nm: ~str) -> Path {
-        Path(getopts::opt_str(m, nm))
-    }
-
-    return {compile_lib_path: getopts::opt_str(matches, ~"compile-lib-path"),
-         run_lib_path: getopts::opt_str(matches, ~"run-lib-path"),
-         rustc_path: opt_path(matches, ~"rustc-path"),
-         src_base: opt_path(matches, ~"src-base"),
-         build_base: opt_path(matches, ~"build-base"),
-         aux_base: opt_path(matches, ~"aux-base"),
-         stage_id: getopts::opt_str(matches, ~"stage-id"),
-         mode: str_mode(getopts::opt_str(matches, ~"mode")),
-         run_ignored: getopts::opt_present(matches, ~"ignored"),
-         filter:
-             if vec::len(matches.free) > 0u {
-                 option::Some(matches.free[0])
-             } else { option::None },
-         logfile: option::map(&getopts::opt_maybe_str(matches,
-                                                     ~"logfile"),
-                              |s| Path(*s)),
-         runtool: getopts::opt_maybe_str(matches, ~"runtool"),
-         rustcflags: getopts::opt_maybe_str(matches, ~"rustcflags"),
-         jit: getopts::opt_present(matches, ~"jit"),
-         verbose: getopts::opt_present(matches, ~"verbose")};
-}
-
-fn log_config(config: config) {
-    let c = config;
-    logv(c, fmt!("configuration:"));
-    logv(c, fmt!("compile_lib_path: %s", config.compile_lib_path));
-    logv(c, fmt!("run_lib_path: %s", config.run_lib_path));
-    logv(c, fmt!("rustc_path: %s", config.rustc_path.to_str()));
-    logv(c, fmt!("src_base: %s", config.src_base.to_str()));
-    logv(c, fmt!("build_base: %s", config.build_base.to_str()));
-    logv(c, fmt!("stage_id: %s", config.stage_id));
-    logv(c, fmt!("mode: %s", mode_str(config.mode)));
-    logv(c, fmt!("run_ignored: %b", config.run_ignored));
-    logv(c, fmt!("filter: %s", opt_str(config.filter)));
-    logv(c, fmt!("runtool: %s", opt_str(config.runtool)));
-    logv(c, fmt!("rustcflags: %s", opt_str(config.rustcflags)));
-    logv(c, fmt!("jit: %b", config.jit));
-    logv(c, fmt!("verbose: %b", config.verbose));
-    logv(c, fmt!("\n"));
-}
-
-fn opt_str(maybestr: Option<~str>) -> ~str {
-    match maybestr { option::Some(s) => s, option::None => ~"(none)" }
-}
-
-fn str_opt(maybestr: ~str) -> Option<~str> {
-    if maybestr != ~"(none)" { option::Some(maybestr) } else { option::None }
-}
-
-fn str_mode(s: ~str) -> mode {
-    match s {
-      ~"compile-fail" => mode_compile_fail,
-      ~"run-fail" => mode_run_fail,
-      ~"run-pass" => mode_run_pass,
-      ~"pretty" => mode_pretty,
-      _ => fail ~"invalid mode"
-    }
-}
-
-fn mode_str(mode: mode) -> ~str {
-    match mode {
-      mode_compile_fail => ~"compile-fail",
-      mode_run_fail => ~"run-fail",
-      mode_run_pass => ~"run-pass",
-      mode_pretty => ~"pretty"
-    }
-}
-
-fn run_tests(config: config) {
-    let opts = test_opts(config);
-    let tests = make_tests(config);
-    let res = test::run_tests_console(&opts, tests);
-    if !res { fail ~"Some tests failed"; }
-}
-
-fn test_opts(config: config) -> test::TestOpts {
-    {filter:
-         match config.filter {
-           option::Some(s) => option::Some(s),
-           option::None => option::None
-         },
-     run_ignored: config.run_ignored,
-     logfile:
-         match config.logfile {
-           option::Some(s) => option::Some(s.to_str()),
-           option::None => option::None
-         }
-    }
-}
-
-fn make_tests(config: config) -> ~[test::TestDesc] {
-    debug!("making tests from %s",
-           config.src_base.to_str());
-    let mut tests = ~[];
-    for os::list_dir_path(&config.src_base).each |file| {
-        let file = copy *file;
-        debug!("inspecting file %s", file.to_str());
-        if is_test(config, file) {
-            tests.push(make_test(config, file))
-        }
-    }
-    move tests
-}
-
-fn is_test(config: config, testfile: &Path) -> bool {
-    // Pretty-printer does not work with .rc files yet
-    let valid_extensions =
-        match config.mode {
-          mode_pretty => ~[~".rs"],
-          _ => ~[~".rc", ~".rs"]
-        };
-    let invalid_prefixes = ~[~".", ~"#", ~"~"];
-    let name = testfile.filename().get();
-
-    let mut valid = false;
-
-    for valid_extensions.each |ext| {
-        if str::ends_with(name, *ext) { valid = true; }
-    }
-
-    for invalid_prefixes.each |pre| {
-        if str::starts_with(name, *pre) { valid = false; }
-    }
-
-    return valid;
-}
-
-fn make_test(config: config, testfile: &Path) ->
-   test::TestDesc {
-    {
-        name: make_test_name(config, testfile),
-        testfn: make_test_closure(config, testfile),
-        ignore: header::is_test_ignored(config, testfile),
-        should_fail: false
-    }
-}
-
-fn make_test_name(config: config, testfile: &Path) -> ~str {
-    fmt!("[%s] %s", mode_str(config.mode), testfile.to_str())
-}
-
-fn make_test_closure(config: config, testfile: &Path) -> test::TestFn {
-    let testfile = testfile.to_str();
-    fn~() { runtest::run(config, testfile) }
-}
-
-// Local Variables:
-// fill-column: 78;
-// indent-tabs-mode: nil
-// c-basic-offset: 4
-// buffer-file-coding-system: utf-8-unix
-// End:

src/libcore/alternate_crate.rc

+/*!
+
+The Rust core library.
+
+The Rust core library provides runtime features required by the language,
+including the task scheduler and memory allocators, as well as library
+support for Rust built-in types, platform abstractions, and other commonly
+used features.
+
+`core` includes modules corresponding to each of the integer types, each of
+the floating point types, the `bool` type, tuples, characters, strings,
+vectors (`vec`), shared boxes (`box`), and unsafe and borrowed pointers
+(`ptr`).  Additionally, `core` provides task management and creation (`task`),
+communication primitives (`comm` and `pipes`), an efficient vector builder
+(`dvec`), platform abstractions (`os` and `path`), basic I/O abstractions
+(`io`), common traits (`cmp`, `num`, `to_str`), and complete bindings
+to the C standard library (`libc`).
+
+`core` is linked to all crates by default and its contents imported.
+Implicitly, all crates behave as if they included the following prologue:
+
+    extern mod core;
+    use core::*;
+
+*/
+
+#[link(name = "core",
+       vers = "0.5",
+       uuid = "c70c24a7-5551-4f73-8e37-380b11d80be8",
+       url = "https://github.com/mozilla/rust/tree/master/src/libcore")];
+
+#[comment = "The Rust core library"];
+#[license = "MIT"];
+#[crate_type = "lib"];
+
+// Don't link to core. We are core.
+#[no_core];
+
+#[warn(deprecated_mode)];
+#[warn(deprecated_pattern)];
+
+#[warn(vecs_implicitly_copyable)];
+#[deny(non_camel_case_types)];
+
+// Built-in-type support modules
+
+/// Operations and constants for `int`
+#[path = "int-template.rs"]
+#[merge = "int-template/intb.rs"]
+pub mod int;
+
+/// Operations and constants for `i8`
+#[path = "int-template.rs"]
+#[merge = "int-template/i8b.rs"]
+pub mod i8;
+
+/// Operations and constants for `i16`
+#[path = "int-template.rs"]
+#[merge = "int-template/i16b.rs"]
+pub mod i16;
+
+/// Operations and constants for `i32`
+#[path = "int-template.rs"]
+#[merge = "int-template/i32b.rs"]
+pub mod i32;
+
+/// Operations and constants for `i64`
+#[path = "int-template.rs"]
+#[merge = "int-template/i64b.rs"]
+pub mod i64;
+
+/// Operations and constants for `uint`
+#[path = "uint-template.rs"]
+#[merge = "uint-template/uintb.rs"]
+pub mod uint;
+
+/// Operations and constants for `u8`
+#[path = "uint-template.rs"]
+#[merge = "uint-template/u8b.rs"]
+pub mod u8;
+
+/// Operations and constants for `u16`
+#[path = "uint-template.rs"]
+#[merge = "uint-template/u16b.rs"]
+pub mod u16;
+
+/// Operations and constants for `u32`
+#[path = "uint-template.rs"]
+#[merge = "uint-template/u32b.rs"]
+pub mod u32;
+
+/// Operations and constants for `u64`
+#[path = "uint-template.rs"]
+#[merge = "uint-template/u64b.rs"]
+pub mod u64;
+
+
+pub mod box;
+pub mod char;
+pub mod float;
+pub mod f32;
+pub mod f64;
+pub mod str;
+pub mod ptr;
+pub mod vec;
+pub mod at_vec;
+pub mod bool;
+pub mod tuple;
+pub mod unit;
+pub mod owned;
+
+// Ubiquitous-utility-type modules
+
+#[cfg(notest)]
+pub mod ops;
+pub mod cmp;
+pub mod num;
+pub mod hash;
+pub mod either;
+pub mod iter;
+pub mod logging;
+pub mod option;
+#[path="iter-trait.rs"]
+#[merge = "iter-trait/optionb.rs"]
+pub mod option_iter;
+pub mod result;
+pub mod to_str;
+pub mod to_bytes;
+pub mod from_str;
+pub mod util;
+
+// Data structure modules
+
+pub mod dvec;
+#[path="iter-trait.rs"]
+#[merge = "iter-trait/dvecb.rs"]
+pub mod dvec_iter;
+pub mod dlist;
+#[path="iter-trait.rs"]
+#[merge = "iter-trait/dlistb.rs"]
+pub mod dlist_iter;
+pub mod send_map;
+
+// Concurrency
+pub mod comm;
+#[merge = "task/mod.rs"]
+pub mod task;
+pub mod pipes;
+
+// Runtime and language-primitive support
+
+pub mod gc;
+pub mod io;
+pub mod libc;
+pub mod os;
+pub mod path;
+pub mod rand;
+pub mod run;
+pub mod sys;
+pub mod cast;
+pub mod mutable;
+pub mod flate;
+pub mod repr;
+pub mod cleanup;
+pub mod reflect;
+pub mod condition;
+
+// Modules supporting compiler-generated code
+// Exported but not part of the public interface
+
+pub mod extfmt;
+// The test harness links against core, so don't include runtime in tests.
+#[cfg(notest)]
+#[legacy_exports]
+pub mod rt;
+
+// Ideally not exported, but currently is.
+pub mod private;
+
+// For internal use, not exported.
+mod unicode;
+mod cmath;
+mod stackwalk;
+
+// Top-level, visible-everywhere definitions.
+
+// Export various ubiquitous types, constructors, methods.
+
+pub use option::{Some, None};
+pub use Option = option::Option;
+pub use result::{Result, Ok, Err};
+
+pub use Path = path::Path;
+pub use GenericPath = path::GenericPath;
+pub use WindowsPath = path::WindowsPath;
+pub use PosixPath = path::PosixPath;
+
+pub use tuple::{CopyableTuple, ImmutableTuple, ExtendedTupleOps};
+pub use str::{StrSlice, Trimmable};
+pub use vec::{ConstVector, CopyableVector, ImmutableVector};
+pub use vec::{ImmutableEqVector, ImmutableCopyableVector};
+pub use vec::{MutableVector, MutableCopyableVector};
+pub use iter::{BaseIter, ExtendedIter, EqIter, CopyableIter};
+pub use iter::{CopyableOrderedIter, CopyableNonstrictIter, Times};
+pub use num::Num;
+pub use ptr::Ptr;
+pub use to_str::ToStr;
+
+// The following exports are the core operators and kinds
+// The compiler has special knowlege of these so we must not duplicate them
+// when compiling for testing
+#[cfg(notest)]
+pub use ops::{Const, Copy, Send, Owned};
+#[cfg(notest)]
+pub use ops::{Drop};
+#[cfg(notest)]
+pub use ops::{Add, Sub, Mul, Div, Modulo, Neg, BitAnd, BitOr, BitXor};
+#[cfg(notest)]
+pub use ops::{Shl, Shr, Index};
+
+#[cfg(test)]
+extern mod coreops(name = "core", vers = "0.5");
+
+#[cfg(test)]
+pub use coreops::ops::{Const, Copy, Send, Owned};
+#[cfg(test)]
+pub use coreops::ops::{Drop};
+#[cfg(test)]
+pub use coreops::ops::{Add, Sub, Mul, Div, Modulo, Neg, BitAnd, BitOr};
+#[cfg(test)]
+pub use coreops::ops::{BitXor};
+#[cfg(test)]
+pub use coreops::ops::{Shl, Shr, Index};
+
+
+// Export the log levels as global constants. Higher levels mean
+// more-verbosity. Error is the bottom level, default logging level is
+// warn-and-below.
+
+/// The error log level
+pub const error : u32 = 1_u32;
+/// The warning log level
+pub const warn : u32 = 2_u32;
+/// The info log level
+pub const info : u32 = 3_u32;
+/// The debug log level
+pub const debug : u32 = 4_u32;
+
+// A curious inner-module that's not exported that contains the binding
+// 'core' so that macro-expanded references to core::error and such
+// can be resolved within libcore.
+#[doc(hidden)] // FIXME #3538
+mod core {
+    pub const error : u32 = 1_u32;
+    pub const warn : u32 = 2_u32;
+    pub const info : u32 = 3_u32;
+    pub const debug : u32 = 4_u32;
+}
+
+// Similar to above. Some magic to make core testable.
+#[cfg(test)]
+mod std {
+    extern mod std(vers = "0.5");
+    pub use std::test;
+}
+
+// Local Variables:
+// mode: rust;
+// fill-column: 78;
+// indent-tabs-mode: nil
+// c-basic-offset: 4
+// buffer-file-coding-system: utf-8-unix
+// End:

src/libcore/core.rc

+// DIVERT
+
 /*!
 
 The Rust core library.

src/libcore/int-template/i16b.rs

+mod inst {
+    pub type T = i16;
+    pub const bits: uint = u16::bits;
+}
\ No newline at end of file

src/libcore/int-template/i32b.rs

+mod inst {
+    pub type T = i32;
+    pub const bits: uint = u32::bits;
+}

src/libcore/int-template/i64b.rs

+mod inst {
+    pub type T = i64;
+    pub const bits: uint = u64::bits;
+}
\ No newline at end of file

src/libcore/int-template/i8b.rs

+mod inst {
+    pub type T = i8;
+    pub const bits: uint = u8::bits;
+}
\ No newline at end of file

src/libcore/int-template/intb.rs

+pub use inst::pow;
+
+mod inst {
+    pub type T = int;
+    pub const bits: uint = uint::bits;
+
+    /// Returns `base` raised to the power of `exponent`
+    pub fn pow(base: int, exponent: uint) -> int {
+        if exponent == 0u {
+            //Not mathemtically true if ~[base == 0]
+            return 1;
+        }
+        if base     == 0  { return 0; }
+        let mut my_pow  = exponent;
+        let mut acc     = 1;
+        let mut multiplier = base;
+        while(my_pow > 0u) {
+            if my_pow % 2u == 1u {
+                acc *= multiplier;
+            }
+            my_pow     /= 2u;
+            multiplier *= multiplier;
+        }
+        return acc;
+    }
+
+    #[test]
+    fn test_pow() {
+        assert (pow(0, 0u) == 1);
+        assert (pow(0, 1u) == 0);
+        assert (pow(0, 2u) == 0);
+        assert (pow(-1, 0u) == 1);
+        assert (pow(1, 0u) == 1);
+        assert (pow(-3, 2u) == 9);
+        assert (pow(-3, 3u) == -27);
+        assert (pow(4, 9u) == 262144);
+    }
+
+    #[test]
+    fn test_overflows() {
+        assert (max_value > 0);
+        assert (min_value <= 0);
+        assert (min_value + max_value + 1 == 0);
+    }
+}
\ No newline at end of file

src/libcore/iter-trait/dlistb.rs

+mod inst {
+    #[allow(non_camel_case_types)]
+    pub type IMPL_T<A> = dlist::DList<A>;
+
+    /**
+    * Iterates through the current contents.
+    *
+    * Attempts to access this dlist during iteration are allowed (to
+    * allow for e.g. breadth-first search with in-place enqueues), but
+    * removing the current node is forbidden.
+    */
+    pub pure fn EACH<A>(self: &IMPL_T<A>, f: fn(v: &A) -> bool) {
+        let mut link = self.peek_n();
+        while option::is_some(&link) {
+            let nobe = option::get(link);
+            assert nobe.linked;
+            if !f(&nobe.data) { break; }
+            // Check (weakly) that the user didn't do a remove.
+            if self.size == 0 {
+                fail ~"The dlist became empty during iteration??"
+            }
+            if !nobe.linked ||
+                (!((nobe.prev.is_some()
+                    || box::ptr_eq(*self.hd.expect(~"headless dlist?"),
+                                   *nobe))
+                   && (nobe.next.is_some()
+                    || box::ptr_eq(*self.tl.expect(~"tailless dlist?"),
+                                   *nobe)))) {
+                fail ~"Removing a dlist node during iteration is forbidden!"
+            }
+            link = nobe.next_link();
+        }
+    }
+
+    pub pure fn SIZE_HINT<A>(self: &IMPL_T<A>) -> Option<uint> {
+        Some(self.len())
+    }
+}
\ No newline at end of file

src/libcore/iter-trait/dvecb.rs

+mod inst {
+    #[allow(non_camel_case_types)]
+    pub type IMPL_T<A> = dvec::DVec<A>;
+
+    /**
+    * Iterates through the current contents.
+    *
+    * Attempts to access this dvec during iteration will fail.
+    */
+    pub pure fn EACH<A>(self: &IMPL_T<A>, f: fn(v: &A) -> bool) {
+        unsafe {
+            do self.swap |v| {
+                v.each(f);
+                move v
+            }
+        }
+    }
+
+    pub pure fn SIZE_HINT<A>(self: &IMPL_T<A>) -> Option<uint> {
+        Some(self.len())
+    }
+}
\ No newline at end of file

src/libcore/iter-trait/optionb.rs

+mod inst {
+    #[allow(non_camel_case_types)]
+    pub type IMPL_T<A> = Option<A>;
+
+    pub pure fn EACH<A>(self: &IMPL_T<A>, f: fn(v: &A) -> bool) {
+        match *self {
+            None => (),
+            Some(ref a) => { f(a); }
+        }
+    }
+
+    pub pure fn SIZE_HINT<A>(self: &IMPL_T<A>) -> Option<uint> {
+        match *self {
+            None => Some(0),
+            Some(_) => Some(1)
+        }
+    }
+}
\ No newline at end of file

src/libcore/task/mod.rs

+
+mod local_data_priv;
+
+pub mod local_data;
+
+pub mod rt;
+
+pub mod spawn;

src/libcore/uint-template/u16b.rs

+mod inst {
+    pub type T = u16;
+    pub const bits: uint = 16;
+}

src/libcore/uint-template/u32b.rs

+mod inst {
+    pub type T = u32;
+    pub const bits: uint = 32;
+}
\ No newline at end of file

src/libcore/uint-template/u64b.rs

+mod inst {
+    pub type T = u64;
+    pub const bits: uint = 64;
+}
\ No newline at end of file

src/libcore/uint-template/u8b.rs

+pub use inst::is_ascii;
+
+mod inst {
+    pub type T = u8;
+    pub const bits: uint = 8;
+
+    // Type-specific functions here. These must be reexported by the
+    // parent module so that they appear in core::u8 and not core::u8::u8;
+
+    pub pure fn is_ascii(x: T) -> bool { return 0 as T == x & 128 as T; }
+}

src/libcore/uint-template/uintb.rs

+pub use inst::{
+    div_ceil, div_round, div_floor, iterate,
+    next_power_of_two
+};
+
+mod inst {
+    pub type T = uint;
+
+    #[cfg(target_arch = "x86")]
+    #[cfg(target_arch = "arm")]
+    pub const bits: uint = 32;
+
+    #[cfg(target_arch = "x86_64")]
+    pub const bits: uint = 64;
+
+    /**
+    * Divide two numbers, return the result, rounded up.
+    *
+    * # Arguments
+    *
+    * * x - an integer
+    * * y - an integer distinct from 0u
+    *
+    * # Return value
+    *
+    * The smallest integer `q` such that `x/y <= q`.
+    */
+    pub pure fn div_ceil(x: uint, y: uint) -> uint {
+        let div = x / y;
+        if x % y == 0u { div }
+        else { div + 1u }
+    }
+
+    /**
+    * Divide two numbers, return the result, rounded to the closest integer.
+    *
+    * # Arguments
+    *
+    * * x - an integer
+    * * y - an integer distinct from 0u
+    *
+    * # Return value
+    *
+    * The integer `q` closest to `x/y`.
+    */
+    pub pure fn div_round(x: uint, y: uint) -> uint {
+        let div = x / y;
+        if x % y * 2u  < y { div }
+        else { div + 1u }
+    }
+
+    /**
+    * Divide two numbers, return the result, rounded down.
+    *
+    * Note: This is the same function as `div`.
+    *
+    * # Arguments
+    *
+    * * x - an integer
+    * * y - an integer distinct from 0u
+    *
+    * # Return value
+    *
+    * The smallest integer `q` such that `x/y <= q`. This
+    * is either `x/y` or `x/y + 1`.
+    */
+    pub pure fn div_floor(x: uint, y: uint) -> uint { return x / y; }
+
+    /**
+    * Iterate over the range [`lo`..`hi`), or stop when requested
+    *
+    * # Arguments
+    *
+    * * lo - The integer at which to start the loop (included)
+    * * hi - The integer at which to stop the loop (excluded)
+    * * it - A block to execute with each consecutive integer of the range.
+    *        Return `true` to continue, `false` to stop.
+    *
+    * # Return value
+    *
+    * `true` If execution proceeded correctly, `false` if it was interrupted,
+    * that is if `it` returned `false` at any point.
+    */
+    pub pure fn iterate(lo: uint, hi: uint, it: fn(uint) -> bool) -> bool {
+        let mut i = lo;
+        while i < hi {
+            if (!it(i)) { return false; }
+            i += 1u;
+        }
+        return true;
+    }
+
+    /// Returns the smallest power of 2 greater than or equal to `n`
+    #[inline(always)]
+    pub fn next_power_of_two(n: uint) -> uint {
+        let halfbits: uint = sys::size_of::<uint>() * 4u;
+        let mut tmp: uint = n - 1u;
+        let mut shift: uint = 1u;
+        while shift <= halfbits { tmp |= tmp >> shift; shift <<= 1u; }
+        return tmp + 1u;
+    }
+
+    #[test]
+    fn test_next_power_of_two() {
+        assert (uint::next_power_of_two(0u) == 0u);
+        assert (uint::next_power_of_two(1u) == 1u);
+        assert (uint::next_power_of_two(2u) == 2u);
+        assert (uint::next_power_of_two(3u) == 4u);
+        assert (uint::next_power_of_two(4u) == 4u);
+        assert (uint::next_power_of_two(5u) == 8u);
+        assert (uint::next_power_of_two(6u) == 8u);
+        assert (uint::next_power_of_two(7u) == 8u);
+        assert (uint::next_power_of_two(8u) == 8u);
+        assert (uint::next_power_of_two(9u) == 16u);
+        assert (uint::next_power_of_two(10u) == 16u);
+        assert (uint::next_power_of_two(11u) == 16u);
+        assert (uint::next_power_of_two(12u) == 16u);
+        assert (uint::next_power_of_two(13u) == 16u);
+        assert (uint::next_power_of_two(14u) == 16u);
+        assert (uint::next_power_of_two(15u) == 16u);
+        assert (uint::next_power_of_two(16u) == 16u);
+        assert (uint::next_power_of_two(17u) == 32u);
+        assert (uint::next_power_of_two(18u) == 32u);
+        assert (uint::next_power_of_two(19u) == 32u);
+        assert (uint::next_power_of_two(20u) == 32u);
+        assert (uint::next_power_of_two(21u) == 32u);
+        assert (uint::next_power_of_two(22u) == 32u);
+        assert (uint::next_power_of_two(23u) == 32u);
+        assert (uint::next_power_of_two(24u) == 32u);
+        assert (uint::next_power_of_two(25u) == 32u);
+        assert (uint::next_power_of_two(26u) == 32u);
+        assert (uint::next_power_of_two(27u) == 32u);
+        assert (uint::next_power_of_two(28u) == 32u);
+        assert (uint::next_power_of_two(29u) == 32u);
+        assert (uint::next_power_of_two(30u) == 32u);
+        assert (uint::next_power_of_two(31u) == 32u);
+        assert (uint::next_power_of_two(32u) == 32u);
+        assert (uint::next_power_of_two(33u) == 64u);
+        assert (uint::next_power_of_two(34u) == 64u);
+        assert (uint::next_power_of_two(35u) == 64u);
+        assert (uint::next_power_of_two(36u) == 64u);
+        assert (uint::next_power_of_two(37u) == 64u);
+        assert (uint::next_power_of_two(38u) == 64u);
+        assert (uint::next_power_of_two(39u) == 64u);
+    }
+
+    #[test]
+    fn test_overflows() {
+        assert (uint::max_value > 0u);
+        assert (uint::min_value <= 0u);
+        assert (uint::min_value + uint::max_value + 1u == 0u);
+    }
+
+    #[test]
+    fn test_div() {
+        assert(uint::div_floor(3u, 4u) == 0u);
+        assert(uint::div_ceil(3u, 4u)  == 1u);
+        assert(uint::div_round(3u, 4u) == 1u);
+    }
+}
\ No newline at end of file

src/librustc/driver/mod.rs

+#[legacy_exports];
+#[legacy_exports]
+mod driver;
+#[legacy_exports]
+mod session;

src/librustc/driver/session.rs

@@ -357,7 +357,6 @@ fn make_crate(with_bin: bool, with_lib: bool) -> @ast::crate {
         if with_bin { attrs += ~[make_crate_type_attr(~"bin")]; }
         if with_lib { attrs += ~[make_crate_type_attr(~"lib")]; }
         @ast_util::respan(ast_util::dummy_sp(), {
-            directives: ~[],
             module: {view_items: ~[], items: ~[]},
             attrs: attrs,
             config: ~[]

src/librustc/middle/borrowck/mod.rs

+#[legacy_exports];
+#[legacy_exports]
+mod check_loans;
+#[legacy_exports]
+mod gather_loans;
+#[legacy_exports]
+mod loan;
+#[legacy_exports]
+mod preserve;