---

yaml
---
r: 85703
b: refs/heads/dist-snap
c: 35ec01a
h: refs/heads/master
i:
  85701: 1b570ed
  85699: f08ceb0
  85695: 768d2ea
v: v3

Author: brandonson

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 0983ebe5310d4eb6d289f636f7ed0536c08bbc0e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 77df8b809a3927ffcdd2c43d48783c97a25712a8
+refs/heads/dist-snap: 35ec01a3f72313d098722163e74f84bd1d047296
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/doc/rust.md

@@ -851,6 +851,38 @@ In this example, the module `quux` re-exports all of the public names defined in
 
 Also note that the paths contained in `use` items are relative to the crate root.
 So, in the previous example, the `use` refers to `quux::foo::*`, and not simply to `foo::*`.
+This also means that top-level module declarations should be at the crate root if direct usage
+of the declared modules within `use` items is desired.  It is also possible to use `self` and `super`
+at the beginning of a `use` item to refer to the current and direct parent modules respectively.
+All rules regarding accessing declared modules in `use` declarations applies to both module declarations
+and `extern mod` declarations.
+
+An example of what will and will not work for `use` items:
+~~~~
+# #[allow(unused_imports)];
+use foo::extra;          // good: foo is at the root of the crate
+use foo::baz::foobaz;    // good: foo is at the root of the crate
+
+mod foo {
+    extern mod extra;
+
+    use foo::extra::list;  // good: foo is at crate root
+//  use extra::*;          // bad:  extra is not at the crate root
+    use self::baz::foobaz; // good: self refers to module 'foo'
+    use foo::bar::foobar;  // good: foo is at crate root
+
+    pub mod bar {
+        pub fn foobar() { }
+    }
+
+    pub mod baz {
+        use super::bar::foobar; // good: super refers to module 'foo'
+        pub fn foobaz() { }
+    }
+}
+
+fn main() {}
+~~~~
 
 ### Functions
 

branches/dist-snap/src/librust/rust.rs

@@ -45,7 +45,7 @@ impl ValidUsage {
 
 enum Action {
     Call(extern "Rust" fn(args: &[~str]) -> ValidUsage),
-    CallMain(&'static str, extern "Rust" fn(&[~str])),
+    CallMain(&'static str, extern "Rust" fn()),
 }
 
 enum UsageSource<'self> {
@@ -69,7 +69,7 @@ static NUM_OF_COMMANDS: uint = 7;
 static COMMANDS: [Command<'static>, .. NUM_OF_COMMANDS] = [
     Command{
         cmd: "build",
-        action: CallMain("rustc", rustc::main_args),
+        action: CallMain("rustc", rustc::main),
         usage_line: "compile rust source files",
         usage_full: UsgCall(rustc_help),
     },
@@ -95,19 +95,19 @@ static COMMANDS: [Command<'static>, .. NUM_OF_COMMANDS] = [
     },
     Command{
         cmd: "doc",
-        action: CallMain("rustdoc", rustdoc::main_args),
+        action: CallMain("rustdoc", rustdoc::main),
         usage_line: "generate documentation from doc comments",
         usage_full: UsgCall(rustdoc::config::usage),
     },
     Command{
         cmd: "pkg",
-        action: CallMain("rustpkg", rustpkg::main_args),
+        action: CallMain("rustpkg", rustpkg::main),
         usage_line: "download, build, install rust packages",
         usage_full: UsgCall(rustpkg::usage::general),
     },
     Command{
         cmd: "sketch",
-        action: CallMain("rusti", rusti::main_args),
+        action: CallMain("rusti", rusti::main),
         usage_line: "run a rust interpreter",
         usage_full: UsgStr("\nUsage:\trusti"),
     },
@@ -164,7 +164,7 @@ fn cmd_test(args: &[~str]) -> ValidUsage {
         [ref filename] => {
             let test_exec = Path(*filename).filestem().unwrap() + "test~";
             invoke("rustc", &[~"--test", filename.to_owned(),
-                              ~"-o", test_exec.to_owned()], rustc::main_args);
+                              ~"-o", test_exec.to_owned()], rustc::main);
             let exit_code = run::process_status(~"./" + test_exec, []);
             Valid(exit_code)
         }
@@ -177,18 +177,19 @@ fn cmd_run(args: &[~str]) -> ValidUsage {
         [ref filename, ..prog_args] => {
             let exec = Path(*filename).filestem().unwrap() + "~";
             invoke("rustc", &[filename.to_owned(), ~"-o", exec.to_owned()],
-                   rustc::main_args);
+                   rustc::main);
             let exit_code = run::process_status(~"./"+exec, prog_args);
             Valid(exit_code)
         }
         _ => Invalid
     }
 }
 
-fn invoke(prog: &str, args: &[~str], f: &fn(&[~str])) {
+fn invoke(prog: &str, args: &[~str], f: &fn()) {
     let mut osargs = ~[prog.to_owned()];
     osargs.push_all_move(args.to_owned());
-    f(osargs);
+    os::set_args(osargs);
+    f();
 }
 
 fn do_command(command: &Command, args: &[~str]) -> ValidUsage {

branches/dist-snap/src/librustc/rustc.rs

@@ -191,11 +191,11 @@ pub fn describe_debug_flags() {
     }
 }
 
-pub fn run_compiler(args: &[~str], demitter: diagnostic::Emitter) {
+pub fn run_compiler(args: &~[~str], demitter: diagnostic::Emitter) {
     // Don't display log spew by default. Can override with RUST_LOG.
     ::std::logging::console_off();
 
-    let mut args = args.to_owned();
+    let mut args = (*args).clone();
     let binary = args.shift().to_managed();
 
     if args.is_empty() { usage(binary); return; }
@@ -381,12 +381,7 @@ pub fn monitor(f: ~fn(diagnostic::Emitter)) {
 
 pub fn main() {
     let args = os::args();
-    main_args(args);
-}
-
-pub fn main_args(args: &[~str]) {
-    let owned_args = args.to_owned();
     do monitor |demitter| {
-        run_compiler(owned_args, demitter);
+        run_compiler(&args, demitter);
     }
 }

branches/dist-snap/src/librustdoc/rustdoc.rs

@@ -59,10 +59,7 @@ pub mod prune_private_pass;
 
 pub fn main() {
     let args = os::args();
-    main_args(args);
-}
 
-pub fn main_args(args: &[~str]) {
     if args.iter().any(|x| "-h" == *x) || args.iter().any(|x| "--help" == *x) {
         config::usage();
         return;

branches/dist-snap/src/librusti/rusti.rs

@@ -498,13 +498,9 @@ pub fn run_line(repl: &mut Repl, input: @io::Reader, out: @io::Writer, line: ~st
 }
 
 pub fn main() {
-    let args = os::args();
-    main_args(args);
-}
-
-pub fn main_args(args: &[~str]) {
     #[fixed_stack_segment]; #[inline(never)];
 
+    let args = os::args();
     let input = io::stdin();
     let out = io::stdout();
     let mut repl = Repl {

branches/dist-snap/src/librustpkg/rustpkg.rs

@@ -466,11 +466,8 @@ impl CtxMethods for Ctx {
 
 pub fn main() {
     io::println("WARNING: The Rust package manager is experimental and may be unstable");
-    let args = os::args();
-    main_args(args);
-}
 
-pub fn main_args(args: &[~str]) {
+    let args = os::args();
     let opts = ~[getopts::optflag("h"), getopts::optflag("help"),
                  getopts::optflag("j"), getopts::optflag("json"),
                  getopts::optmulti("c"), getopts::optmulti("cfg")];

branches/dist-snap/src/libstd/os.rs

@@ -36,6 +36,7 @@ use iterator::range;
 use libc;
 use libc::{c_char, c_void, c_int, size_t};
 use libc::FILE;
+use local_data;
 use option::{Some, None};
 use os;
 use prelude::*;
@@ -1187,7 +1188,7 @@ unsafe fn load_argc_and_argv(argc: c_int, argv: **c_char) -> ~[~str] {
  * Returns a list of the command line arguments.
  */
 #[cfg(target_os = "macos")]
-fn real_args() -> ~[~str] {
+pub fn real_args() -> ~[~str] {
     #[fixed_stack_segment]; #[inline(never)];
 
     unsafe {
@@ -1200,7 +1201,7 @@ fn real_args() -> ~[~str] {
 #[cfg(target_os = "linux")]
 #[cfg(target_os = "android")]
 #[cfg(target_os = "freebsd")]
-fn real_args() -> ~[~str] {
+pub fn real_args() -> ~[~str] {
     use rt;
 
     match rt::args::clone() {
@@ -1210,7 +1211,7 @@ fn real_args() -> ~[~str] {
 }
 
 #[cfg(windows)]
-fn real_args() -> ~[~str] {
+pub fn real_args() -> ~[~str] {
     #[fixed_stack_segment]; #[inline(never)];
 
     let mut nArgs: c_int = 0;
@@ -1260,10 +1261,28 @@ struct OverriddenArgs {
     val: ~[~str]
 }
 
+static overridden_arg_key: local_data::Key<@OverriddenArgs> = &local_data::Key;
+
 /// Returns the arguments which this program was started with (normally passed
 /// via the command line).
+///
+/// The return value of the function can be changed by invoking the
+/// `os::set_args` function.
 pub fn args() -> ~[~str] {
-    real_args()
+    match local_data::get(overridden_arg_key, |k| k.map(|&k| *k)) {
+        None => real_args(),
+        Some(args) => args.val.clone()
+    }
+}
+
+/// For the current task, overrides the task-local cache of the arguments this
+/// program had when it started. These new arguments are only available to the
+/// current task via the `os::args` method.
+pub fn set_args(new_args: ~[~str]) {
+    let overridden_args = @OverriddenArgs {
+        val: new_args.clone()
+    };
+    local_data::set(overridden_arg_key, overridden_args);
 }
 
 // FIXME #6100 we should really use an internal implementation of this - using
@@ -1751,7 +1770,7 @@ mod tests {
     use libc;
     use option::Some;
     use option;
-    use os::{env, getcwd, getenv, make_absolute, args};
+    use os::{env, getcwd, getenv, make_absolute, real_args};
     use os::{remove_file, setenv, unsetenv};
     use os;
     use path::Path;
@@ -1769,7 +1788,7 @@ mod tests {
 
     #[test]
     pub fn test_args() {
-        let a = args();
+        let a = real_args();
         assert!(a.len() >= 1);
     }