---

yaml
---
r: 98219
b: refs/heads/master
c: 2784313
h: refs/heads/master
i:
  98217: d70245a
  98215: e75d207
v: v3

Author: alexcrichton

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: b5a110c7feed3a87a0daee1e829fa0cb03026a4e
+refs/heads/master: 27843133448df3315af1a07dc6700d7754709a97
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: b6400f998497c3958f40997a71756ead344a776d
 refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36

trunk/src/librustc/front/std_inject.rs

@@ -73,7 +73,7 @@ impl fold::Folder for StandardLibraryInjector {
                                          with_version("std"),
                                          ast::DUMMY_NODE_ID),
             attrs: ~[],
-            vis: ast::Inherited,
+            vis: ast::Private,
             span: DUMMY_SP
         }];
 
@@ -83,15 +83,15 @@ impl fold::Folder for StandardLibraryInjector {
                                              with_version("green"),
                                              ast::DUMMY_NODE_ID),
                 attrs: ~[],
-                vis: ast::Inherited,
+                vis: ast::Private,
                 span: DUMMY_SP
             });
             vis.push(ast::ViewItem {
                 node: ast::ViewItemExternMod(self.sess.ident_of("rustuv"),
                                              with_version("rustuv"),
                                              ast::DUMMY_NODE_ID),
                 attrs: ~[],
-                vis: ast::Inherited,
+                vis: ast::Private,
                 span: DUMMY_SP
             });
         }
@@ -147,7 +147,7 @@ impl fold::Folder for StandardLibraryInjector {
         let vi2 = ast::ViewItem {
             node: ast::ViewItemUse(~[vp]),
             attrs: ~[],
-            vis: ast::Inherited,
+            vis: ast::Private,
             span: DUMMY_SP,
         };
 

trunk/src/librustc/front/test.rs

@@ -301,7 +301,7 @@ fn mk_std(cx: &TestCtxt) -> ast::ViewItem {
     ast::ViewItem {
         node: vi,
         attrs: ~[],
-        vis: ast::Inherited,
+        vis: ast::Public,
         span: DUMMY_SP
     }
 }

trunk/src/librustc/lib.rs

@@ -38,21 +38,16 @@ use middle::lint;
 
 use d = driver::driver;
 
-use std::cast;
-use std::comm;
 use std::io;
-use std::io::Reader;
 use std::num;
 use std::os;
-use std::result;
 use std::str;
 use std::task;
 use std::vec;
 use extra::getopts::groups;
 use extra::getopts;
 use syntax::ast;
 use syntax::attr;
-use syntax::codemap;
 use syntax::diagnostic::Emitter;
 use syntax::diagnostic;
 use syntax::parse;
@@ -126,21 +121,6 @@ pub mod lib {
     pub mod llvmdeps;
 }
 
-// A curious inner module that allows ::std::foo to be available in here for
-// macros.
-/*
-mod std {
-    pub use std::clone;
-    pub use std::cmp;
-    pub use std::os;
-    pub use std::str;
-    pub use std::sys;
-    pub use std::to_bytes;
-    pub use std::unstable;
-    pub use extra::serialize;
-}
-*/
-
 pub fn version(argv0: &str) {
     let vers = match option_env!("CFG_VERSION") {
         Some(vers) => vers,
@@ -344,45 +324,12 @@ fn parse_crate_attrs(sess: session::Session,
     }
 }
 
-#[deriving(Eq)]
-pub enum monitor_msg {
-    fatal,
-    done,
-}
-
-struct RustcEmitter {
-    ch_capture: comm::SharedChan<monitor_msg>
-}
-
-impl diagnostic::Emitter for RustcEmitter {
-    fn emit(&self,
-            cmsp: Option<(&codemap::CodeMap, codemap::Span)>,
-            msg: &str,
-            lvl: diagnostic::Level) {
-        if lvl == diagnostic::Fatal {
-            let this = unsafe { cast::transmute_mut(self) };
-            this.ch_capture.send(fatal)
-        }
-
-        diagnostic::DefaultEmitter.emit(cmsp, msg, lvl)
-    }
-}
-
-/*
-This is a sanity check that any failure of the compiler is performed
-through the diagnostic module and reported properly - we shouldn't be calling
-plain-old-fail on any execution path that might be taken. Since we have
-console logging off by default, hitting a plain fail statement would make the
-compiler silently exit, which would be terrible.
-
-This method wraps the compiler in a subtask and injects a function into the
-diagnostic emitter which records when we hit a fatal error. If the task
-fails without recording a fatal error then we've encountered a compiler
-bug and need to present an error.
-*/
+/// Run a procedure which will detect failures in the compiler and print nicer
+/// error messages rather than just failing the test.
+///
+/// The diagnostic emitter yielded to the procedure should be used for reporting
+/// errors of the compiler.
 pub fn monitor(f: proc(@diagnostic::Emitter)) {
-    use std::comm::*;
-
     // XXX: This is a hack for newsched since it doesn't support split stacks.
     // rustc needs a lot of stack! When optimizations are disabled, it needs
     // even *more* stack than usual as well.
@@ -391,8 +338,6 @@ pub fn monitor(f: proc(@diagnostic::Emitter)) {
     #[cfg(not(rtopt))]
     static STACK_SIZE: uint = 20000000; // 20MB
 
-    let (p, ch) = SharedChan::new();
-    let ch_capture = ch.clone();
     let mut task_builder = task::task();
     task_builder.name("rustc");
 
@@ -402,30 +347,18 @@ pub fn monitor(f: proc(@diagnostic::Emitter)) {
         task_builder.opts.stack_size = Some(STACK_SIZE);
     }
 
-    match task_builder.try(proc() {
-        let ch = ch_capture.clone();
-        // The 'diagnostics emitter'. Every error, warning, etc. should
-        // go through this function.
-        let demitter = @RustcEmitter {
-            ch_capture: ch.clone(),
-        } as @diagnostic::Emitter;
-
-        struct finally {
-            ch: SharedChan<monitor_msg>,
-        }
+    let (p, c) = Chan::new();
+    let w = io::ChanWriter::new(c);
+    let mut r = io::PortReader::new(p);
 
-        impl Drop for finally {
-            fn drop(&mut self) { self.ch.send(done); }
-        }
-
-        let _finally = finally { ch: ch };
-
-        f(demitter);
+    match task_builder.try(proc() {
+        io::stdio::set_stderr(~w as ~io::Writer);
+        f(@diagnostic::DefaultEmitter)
     }) {
-        result::Ok(_) => { /* fallthrough */ }
-        result::Err(_) => {
+        Ok(()) => { /* fallthrough */ }
+        Err(value) => {
             // Task failed without emitting a fatal diagnostic
-            if p.recv() == done {
+            if !value.is::<diagnostic::FatalError>() {
                 diagnostic::DefaultEmitter.emit(
                     None,
                     diagnostic::ice_msg("unexpected failure"),
@@ -434,17 +367,20 @@ pub fn monitor(f: proc(@diagnostic::Emitter)) {
                 let xs = [
                     ~"the compiler hit an unexpected failure path. \
                      this is a bug",
-                    ~"try running with RUST_LOG=rustc=1 \
-                     to get further details and report the results \
-                     to github.com/mozilla/rust/issues"
                 ];
                 for note in xs.iter() {
                     diagnostic::DefaultEmitter.emit(None,
                                                     *note,
                                                     diagnostic::Note)
                 }
+
+                println!("{}", r.read_to_str());
             }
-            // Fail so the process returns a failure code
+
+            // Fail so the process returns a failure code, but don't pollute the
+            // output with some unnecessary failure messages, we've already
+            // printed everything that we needed to.
+            io::stdio::set_stderr(~io::util::NullWriter as ~io::Writer);
             fail!();
         }
     }

trunk/src/librustc/middle/privacy.rs

@@ -839,32 +839,6 @@ impl Visitor<()> for SanePrivacyVisitor {
         visit::walk_fn(self, fk, fd, b, s, n, ());
         self.in_fn = orig_in_fn;
     }
-
-    fn visit_view_item(&mut self, i: &ast::ViewItem, _: ()) {
-        match i.vis {
-            ast::Inherited => {}
-            ast::Private => {
-                self.tcx.sess.span_err(i.span, "unnecessary visibility \
-                                                qualifier");
-            }
-            ast::Public => {
-                if self.in_fn {
-                    self.tcx.sess.span_err(i.span, "unnecessary `pub`, imports \
-                                                    in functions are never \
-                                                    reachable");
-                } else {
-                    match i.node {
-                        ast::ViewItemExternMod(..) => {
-                            self.tcx.sess.span_err(i.span, "`pub` visibility \
-                                                            is not allowed");
-                        }
-                        _ => {}
-                    }
-                }
-            }
-        }
-        visit::walk_view_item(self, i, ());
-    }
 }
 
 impl SanePrivacyVisitor {

trunk/src/libsyntax/diagnostic.rs

@@ -27,6 +27,11 @@ pub trait Emitter {
             lvl: Level);
 }
 
+/// This structure is used to signify that a task has failed with a fatal error
+/// from the diagnostics. You can use this with the `Any` trait to figure out
+/// how a rustc task died (if so desired).
+pub struct FatalError;
+
 // a span-handler is like a handler but also
 // accepts span information for source-location
 // reporting.
@@ -38,7 +43,7 @@ pub struct SpanHandler {
 impl SpanHandler {
     pub fn span_fatal(@self, sp: Span, msg: &str) -> ! {
         self.handler.emit(Some((&*self.cm, sp)), msg, Fatal);
-        fail!();
+        fail!(FatalError);
     }
     pub fn span_err(@self, sp: Span, msg: &str) {
         self.handler.emit(Some((&*self.cm, sp)), msg, Error);
@@ -72,7 +77,7 @@ pub struct Handler {
 impl Handler {
     pub fn fatal(@self, msg: &str) -> ! {
         self.emit.emit(None, msg, Fatal);
-        fail!();
+        fail!(FatalError);
     }
     pub fn err(@self, msg: &str) {
         self.emit.emit(None, msg, Error);

trunk/src/libsyntax/ext/quote.rs

@@ -648,7 +648,7 @@ fn expand_wrapper(cx: &ExtCtxt,
                   sp: Span,
                   cx_expr: @ast::Expr,
                   expr: @ast::Expr) -> @ast::Expr {
-    let uses = ~[ cx.view_use_glob(sp, ast::Inherited,
+    let uses = ~[ cx.view_use_glob(sp, ast::Public,
                                    ids_ext(~[~"syntax",
                                              ~"ext",
                                              ~"quote",