---

yaml
---
r: 59115
b: refs/heads/incoming
c: be82449
h: refs/heads/master
i:
  59113: 7d83803
  59111: c464803
v: v3

Author: emberian

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c50a9d5b664478e533ba1d1d353213d70c8ad589
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/incoming: 8a5561bc18b45f3a8930a05c3523d4f341b2462f
+refs/heads/incoming: be82449a9a73efd7831b01a523c5f11cd27baa11
 refs/heads/dist-snap: 00dbbd01c2aee72982b3e0f9511ae1d4428c3ba9
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/driver/driver.rs

@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#[no_core];
+extern mod core(vers = "0.7-pre");
+
 #[cfg(rustpkg)]
 extern mod this(name = "rustpkg", vers = "0.7-pre");
 

branches/incoming/src/librust/rust.rc

@@ -20,11 +20,6 @@
 #[license = "MIT/ASL2"];
 #[crate_type = "lib"];
 
-extern mod rustpkg(vers = "0.7-pre");
-extern mod rustdoc(vers = "0.7-pre");
-extern mod rusti(vers = "0.7-pre");
-extern mod rustc(vers = "0.7-pre");
-
 use core::run;
 
 enum ValidUsage {
@@ -41,13 +36,13 @@ impl ValidUsage {
 }
 
 enum Action<'self> {
-    Call(&'self fn(args: &[~str]) -> ValidUsage),
-    CallMain(&'static str, &'self fn()),
+    Exec(&'self str),
+    Call(&'self fn(args: &[~str]) -> ValidUsage)
 }
 
 enum UsageSource<'self> {
-    UsgStr(&'self str),
-    UsgCall(&'self fn()),
+    UsgExec(&'self str),
+    UsgStr(&'self str)
 }
 
 struct Command<'self> {
@@ -60,9 +55,9 @@ struct Command<'self> {
 static commands: &'static [Command<'static>] = &[
     Command{
         cmd: "build",
-        action: CallMain("rustc", rustc::main),
+        action: Exec("rustc"),
         usage_line: "compile rust source files",
-        usage_full: UsgCall(rustc_help),
+        usage_full: UsgExec("rustc --help")
     },
     Command{
         cmd: "run",
@@ -86,21 +81,21 @@ static commands: &'static [Command<'static>] = &[
     },
     Command{
         cmd: "doc",
-        action: CallMain("rustdoc", rustdoc::main),
+        action: Exec("rustdoc"),
         usage_line: "generate documentation from doc comments",
-        usage_full: UsgCall(rustdoc::config::usage),
+        usage_full: UsgExec("rustdoc --help")
     },
     Command{
         cmd: "pkg",
-        action: CallMain("rustpkg", rustpkg::main),
+        action: Exec("rustpkg"),
         usage_line: "download, build, install rust packages",
-        usage_full: UsgCall(rustpkg::usage::general),
+        usage_full: UsgExec("rustpkg --help")
     },
     Command{
         cmd: "sketch",
-        action: CallMain("rusti", rusti::main),
+        action: Exec("rusti"),
         usage_line: "run a rust interpreter",
-        usage_full: UsgStr("\nUsage:\trusti"),
+        usage_full: UsgStr("\nUsage:\trusti")
     },
     Command{
         cmd: "help",
@@ -114,10 +109,6 @@ static commands: &'static [Command<'static>] = &[
     }
 ];
 
-fn rustc_help() {
-    rustc::usage(copy os::args()[0])
-}
-
 fn find_cmd(command_string: &str) -> Option<Command> {
     do commands.find |command| {
         command.cmd == command_string
@@ -129,14 +120,20 @@ fn cmd_help(args: &[~str]) -> ValidUsage {
         match find_cmd(command_string) {
             Some(command) => {
                 match command.action {
-                    CallMain(prog, _) => io::println(fmt!(
+                    Exec(s) => io::println(fmt!(
                         "The %s command is an alias for the %s program.",
-                        command.cmd, prog)),
+                        command.cmd, s)),
                     _       => ()
                 }
                 match command.usage_full {
-                    UsgStr(msg) => io::println(fmt!("%s\n", msg)),
-                    UsgCall(f)  => f(),
+                    UsgStr(msg)          => io::println(fmt!("%s\n", msg)),
+                    UsgExec(commandline) => {
+                        let mut words = ~[];
+                        for str::each_word(commandline) |word| { words.push(word.to_owned()) }
+                        let words = words;
+                        let (prog, args) = (words.head(), words.tail());
+                        run::run_program(*prog, args);
+                    }
                 }
                 Valid
             },
@@ -154,40 +151,50 @@ fn cmd_test(args: &[~str]) -> ValidUsage {
     match args {
         [filename] => {
             let test_exec = Path(filename).filestem().unwrap() + "test~";
-            invoke("rustc", &[~"--test", filename.to_owned(),
-                              ~"-o", test_exec.to_owned()], rustc::main);
-            run::run_program(~"./" + test_exec, []);
+            if run::run_program("rustc", [
+                ~"--test",
+                filename.to_owned(),
+                ~"-o",
+                test_exec.to_owned()
+            ]) == 0 {
+                run::run_program(~"./" + test_exec, []);
+            }
             Valid
         }
-        _ => Invalid
+        _          => Invalid
     }
 }
 
 fn cmd_run(args: &[~str]) -> ValidUsage {
     match args {
         [filename, ..prog_args] => {
             let exec = Path(filename).filestem().unwrap() + "~";
-            invoke("rustc", &[filename.to_owned(), ~"-o", exec.to_owned()],
-                   rustc::main);
-            run::run_program(~"./"+exec, prog_args);
+            if run::run_program("rustc", [
+                filename.to_owned(),
+                ~"-o",
+                exec.to_owned()
+            ]) == 0 {
+                run::run_program(~"./"+exec, prog_args);
+            }
             Valid
         }
-        _ => Invalid
+        _          => Invalid
     }
 }
 
-fn invoke(prog: &str, args: &[~str], f: &fn()) {
-    let mut osargs = ~[prog.to_owned()];
-    osargs.push_all_move(args.to_owned());
-    os::set_args(osargs);
-    f();
-}
-
 fn do_command(command: &Command, args: &[~str]) -> ValidUsage {
     match command.action {
         Call(f) => f(args),
-        CallMain(prog, f) => {
-            invoke(prog, args, f);
+        Exec(commandline) => {
+            let mut words = ~[];
+            for str::each_word(commandline) |word| { words.push(word.to_owned()) }
+            let words = words;
+            let (prog, prog_args) = (words.head(), words.tail());
+            let exitstatus = run::run_program(
+                *prog,
+                vec::append(vec::to_owned(prog_args), args)
+            );
+            os::set_exit_status(exitstatus);
             Valid
         }
     }
@@ -225,9 +232,11 @@ pub fn main() {
     let args = os_args.tail();
 
     if !args.is_empty() {
-        for find_cmd(*args.head()).each |command| {
-            let result = do_command(command, args.tail());
-            if result.is_valid() { return; }
+        for commands.each |command| {
+            if command.cmd == *args.head() {
+                let result = do_command(command, args.tail());
+                if result.is_valid() { return; }
+            }
         }
     }
 

branches/incoming/src/librustc/middle/resolve.rs

@@ -2282,25 +2282,27 @@ pub impl Resolver {
         }
 
         let i = import_resolution;
+        let mut resolve_fail = false;
+        let mut priv_fail = false;
         match (i.value_target, i.type_target) {
             // If this name wasn't found in either namespace, it's definitely
             // unresolved.
-            (None, None) => { return Failed; }
+            (None, None) => { resolve_fail = true; }
             // If it's private, it's also unresolved.
             (Some(t), None) | (None, Some(t)) => {
                 let bindings = &mut *t.bindings;
                 match bindings.type_def {
                     Some(ref type_def) => {
                         if type_def.privacy == Private {
-                            return Failed;
+                            priv_fail = true;
                         }
                     }
                     _ => ()
                 }
                 match bindings.value_def {
                     Some(ref value_def) => {
                         if value_def.privacy == Private {
-                            return Failed;
+                            priv_fail = true;
                         }
                     }
                     _ => ()
@@ -2313,13 +2315,25 @@ pub impl Resolver {
                     (Some(ref value_def), Some(ref type_def)) =>
                         if value_def.privacy == Private
                             && type_def.privacy == Private {
-                            return Failed;
+                                priv_fail = true;
                         },
                     _ => ()
                 }
             }
         }
 
+        if resolve_fail {
+            self.session.err(fmt!("unresolved import: there is no `%s` in `%s`",
+                                  *self.session.str_of(source),
+                                  self.module_to_str(containing_module)));
+            return Failed;
+        } else if priv_fail {
+            self.session.err(fmt!("unresolved import: found `%s` in `%s` but it is private",
+                                  *self.session.str_of(source),
+                                  self.module_to_str(containing_module)));
+            return Failed;
+        }
+
         assert!(import_resolution.outstanding_references >= 1);
         import_resolution.outstanding_references -= 1;
 
@@ -2491,7 +2505,8 @@ pub impl Resolver {
                                                                     *segment_name));
                         return Failed;
                     }
-                    self.session.span_err(span, ~"unresolved name");
+                    self.session.span_err(span, fmt!("unresolved import: could not find %s in %s.",
+                                                     *segment_name, module_name));
                     return Failed;
                 }
                 Indeterminate => {

branches/incoming/src/librustpkg/rustpkg.rc

@@ -42,13 +42,12 @@ use context::Ctx;
 
 mod conditions;
 mod context;
+mod usage;
 mod path_util;
 mod tests;
 mod util;
 mod workspace;
 
-pub mod usage;
-
 /// A PkgScript represents user-supplied custom logic for
 /// special build hooks. This only exists for packages with
 /// an explicit package script.

branches/incoming/src/test/compile-fail/import2.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use baz::zed::bar;  //~ ERROR unresolved name
+use baz::zed::bar;  //~ ERROR unresolved import
 //~^ ERROR failed to resolve import
 
 mod baz {}