rustc: Split diagnostics into "span diagnostics" and "diagnostics".

The former contain a codemap (which is per-crate), and the latter don't. This
will be useful in order to allow more than one crate to be compiled in one run
of the compiler.

3 files changed, 81 insertions, 55 deletions

diff --git a/src/comp/driver/diagnostic.rs b/src/comp/driver/diagnostic.rs
index 0694a357f1b..3d7cbf3701e 100644
--- a/src/comp/driver/diagnostic.rs
+++ b/src/comp/driver/diagnostic.rs
@@ -5,51 +5,82 @@ import codemap::span;
 
 export emitter, emit;
 export level, fatal, error, warning, note;
-export handler, mk_handler;
+export span_handler, handler, mk_span_handler, mk_handler;
+export codemap_span_handler, codemap_handler;
 export ice_msg;
 
 type emitter = fn@(cmsp: option<(codemap::codemap, span)>,
                    msg: str, lvl: level);
 
 
-iface handler {
+iface span_handler {
     fn span_fatal(sp: span, msg: str) -> !;
-    fn fatal(msg: str) -> !;
     fn span_err(sp: span, msg: str);
+    fn span_warn(sp: span, msg: str);
+    fn span_note(sp: span, msg: str);
+    fn span_bug(sp: span, msg: str) -> !;
+    fn span_unimpl(sp: span, msg: str) -> !;
+    fn handler() -> handler;
+}
+
+iface handler {
+    fn fatal(msg: str) -> !;
     fn err(msg: str);
+    fn bump_err_count();
     fn has_errors() -> bool;
     fn abort_if_errors();
-    fn span_warn(sp: span, msg: str);
     fn warn(msg: str);
-    fn span_note(sp: span, msg: str);
     fn note(msg: str);
-    fn span_bug(sp: span, msg: str) -> !;
     fn bug(msg: str) -> !;
-    fn span_unimpl(sp: span, msg: str) -> !;
     fn unimpl(msg: str) -> !;
+    fn emit(cmsp: option<(codemap::codemap, span)>, msg: str, lvl: level);
 }
 
-type codemap_t = @{
-    cm: codemap::codemap,
+type handler_t = @{
     mutable err_count: uint,
-    emit: emitter
+    _emit: emitter
+};
+
+type codemap_t = @{
+    handler: handler,
+    cm: codemap::codemap
 };
 
-impl codemap_handler of handler for codemap_t {
+impl codemap_span_handler of span_handler for codemap_t {
     fn span_fatal(sp: span, msg: str) -> ! {
-        self.emit(some((self.cm, sp)), msg, fatal);
+        self.handler.emit(some((self.cm, sp)), msg, fatal);
         fail;
     }
+    fn span_err(sp: span, msg: str) {
+        self.handler.emit(some((self.cm, sp)), msg, error);
+        self.handler.bump_err_count();
+    }
+    fn span_warn(sp: span, msg: str) {
+        self.handler.emit(some((self.cm, sp)), msg, warning);
+    }
+    fn span_note(sp: span, msg: str) {
+        self.handler.emit(some((self.cm, sp)), msg, note);
+    }
+    fn span_bug(sp: span, msg: str) -> ! {
+        self.span_fatal(sp, ice_msg(msg));
+    }
+    fn span_unimpl(sp: span, msg: str) -> ! {
+        self.span_bug(sp, "unimplemented " + msg);
+    }
+    fn handler() -> handler {
+        self.handler
+    }
+}
+
+impl codemap_handler of handler for handler_t {
     fn fatal(msg: str) -> ! {
-        self.emit(none, msg, fatal);
+        self._emit(none, msg, fatal);
         fail;
     }
-    fn span_err(sp: span, msg: str) {
-        self.emit(some((self.cm, sp)), msg, error);
-        self.err_count += 1u;
-    }
     fn err(msg: str) {
-        self.emit(none, msg, error);
+        self._emit(none, msg, error);
+    }
+    fn bump_err_count() {
         self.err_count += 1u;
     }
     fn has_errors() -> bool { self.err_count > 0u }
@@ -58,36 +89,30 @@ impl codemap_handler of handler for codemap_t {
             self.fatal("aborting due to previous errors");
         }
     }
-    fn span_warn(sp: span, msg: str) {
-        self.emit(some((self.cm, sp)), msg, warning);
-    }
     fn warn(msg: str) {
-        self.emit(none, msg, warning);
-    }
-    fn span_note(sp: span, msg: str) {
-        self.emit(some((self.cm, sp)), msg, note);
+        self._emit(none, msg, warning);
     }
     fn note(msg: str) {
-        self.emit(none, msg, note);
-    }
-    fn span_bug(sp: span, msg: str) -> ! {
-        self.span_fatal(sp, ice_msg(msg));
+        self._emit(none, msg, note);
     }
     fn bug(msg: str) -> ! {
         self.fatal(ice_msg(msg));
     }
-    fn span_unimpl(sp: span, msg: str) -> ! {
-        self.span_bug(sp, "unimplemented " + msg);
-    }
     fn unimpl(msg: str) -> ! { self.bug("unimplemented " + msg); }
+    fn emit(cmsp: option<(codemap::codemap, span)>, msg: str, lvl: level) {
+        self._emit(cmsp, msg, lvl);
+    }
 }
 
 fn ice_msg(msg: str) -> str {
     #fmt["internal compiler error %s", msg]
 }
 
-fn mk_handler(cm: codemap::codemap,
-              emitter: option<emitter>) -> handler {
+fn mk_span_handler(handler: handler, cm: codemap::codemap) -> span_handler {
+    @{ handler: handler, cm: cm } as span_handler
+}
+
+fn mk_handler(emitter: option<emitter>) -> handler {
 
     let emit = alt emitter {
       some(e) { e }
@@ -101,9 +126,8 @@ fn mk_handler(cm: codemap::codemap,
     };
 
     @{
-        cm: cm,
         mutable err_count: 0u,
-        emit: emit
+        _emit: emit
     } as handler
 }
 
diff --git a/src/comp/driver/driver.rs b/src/comp/driver/driver.rs
index 9d8d9ac03b7..f500936aa73 100644
--- a/src/comp/driver/driver.rs
+++ b/src/comp/driver/driver.rs
@@ -299,7 +299,7 @@ fn pretty_print_input(sess: session, cfg: ast::crate_cfg, input: str,
       }
       ppm_expanded | ppm_normal {}
     }
-    pprust::print_crate(sess.codemap, sess.diagnostic, crate, input,
+    pprust::print_crate(sess.codemap, sess.span_diagnostic, crate, input,
                         io::string_reader(src), io::stdout(), ann);
 }
 
@@ -481,21 +481,23 @@ fn build_session(sopts: @session::options, input: str,
         sopts.addl_lib_search_paths);
     let codemap = codemap::new_codemap();
     let diagnostic_handler =
-        diagnostic::mk_handler(codemap, some(demitter));
+        diagnostic::mk_handler(some(demitter));
+    let span_diagnostic_handler =
+        diagnostic::mk_span_handler(diagnostic_handler, codemap);
     @{targ_cfg: target_cfg,
       opts: sopts,
       cstore: cstore,
       parse_sess: @{
           cm: codemap,
           mutable next_id: 1,
-          diagnostic: diagnostic_handler,
+          span_diagnostic: span_diagnostic_handler,
           mutable chpos: 0u,
           mutable byte_pos: 0u
       },
       codemap: codemap,
       // For a library crate, this is always none
       mutable main_fn: none,
-      diagnostic: diagnostic_handler,
+      span_diagnostic: span_diagnostic_handler,
       filesearch: filesearch,
       mutable building_library: false,
       working_dir: fs::dirname(input)}
diff --git a/src/comp/driver/session.rs b/src/comp/driver/session.rs
index ec9d71c6f79..31ddd3d241f 100644
--- a/src/comp/driver/session.rs
+++ b/src/comp/driver/session.rs
@@ -60,53 +60,53 @@ type session = @{targ_cfg: @config,
                  codemap: codemap::codemap,
                  // For a library crate, this is always none
                  mutable main_fn: option::t<node_id>,
-                 diagnostic: diagnostic::handler,
+                 span_diagnostic: diagnostic::span_handler,
                  filesearch: filesearch::filesearch,
                  mutable building_library: bool,
                  working_dir: str};
 
 impl session for session {
     fn span_fatal(sp: span, msg: str) -> ! {
-        self.diagnostic.span_fatal(sp, msg)
+        self.span_diagnostic.span_fatal(sp, msg)
     }
     fn fatal(msg: str) -> ! {
-        self.diagnostic.fatal(msg)
+        self.span_diagnostic.handler().fatal(msg)
     }
     fn span_err(sp: span, msg: str) {
-        self.diagnostic.span_err(sp, msg)
+        self.span_diagnostic.span_err(sp, msg)
     }
     fn err(msg: str) {
-        self.diagnostic.err(msg)
+        self.span_diagnostic.handler().err(msg)
     }
     fn has_errors() -> bool {
-        self.diagnostic.has_errors()
+        self.span_diagnostic.handler().has_errors()
     }
     fn abort_if_errors() {
-        self.diagnostic.abort_if_errors()
+        self.span_diagnostic.handler().abort_if_errors()
     }
     fn span_warn(sp: span, msg: str) {
-        self.diagnostic.span_warn(sp, msg)
+        self.span_diagnostic.span_warn(sp, msg)
     }
     fn warn(msg: str) {
-        self.diagnostic.warn(msg)
+        self.span_diagnostic.handler().warn(msg)
     }
     fn span_note(sp: span, msg: str) {
-        self.diagnostic.span_note(sp, msg)
+        self.span_diagnostic.span_note(sp, msg)
     }
     fn note(msg: str) {
-        self.diagnostic.note(msg)
+        self.span_diagnostic.handler().note(msg)
     }
     fn span_bug(sp: span, msg: str) -> ! {
-        self.diagnostic.span_bug(sp, msg)
+        self.span_diagnostic.span_bug(sp, msg)
     }
     fn bug(msg: str) -> ! {
-        self.diagnostic.bug(msg)
+        self.span_diagnostic.handler().bug(msg)
     }
     fn span_unimpl(sp: span, msg: str) -> ! {
-        self.diagnostic.span_unimpl(sp, msg)
+        self.span_diagnostic.span_unimpl(sp, msg)
     }
     fn unimpl(msg: str) -> ! {
-        self.diagnostic.unimpl(msg)
+        self.span_diagnostic.handler().unimpl(msg)
     }
     fn next_node_id() -> ast::node_id {
         ret syntax::parse::parser::next_node_id(self.parse_sess);