rustc: Refactor codemap::emit_* functions

A codemap is only needed when we have a span so put them both into the option.

src/comp/driver/session.rs

@@ -65,19 +65,19 @@ type session = @{targ_cfg: @config,
 
 impl session for session {
     fn span_fatal(sp: span, msg: str) -> ! {
-        codemap::emit_error(some(sp), msg, self.parse_sess.cm);
+        codemap::emit_error(some((self.parse_sess.cm, sp)), msg);
         fail;
     }
     fn fatal(msg: str) -> ! {
-        codemap::emit_error(none, msg, self.parse_sess.cm);
+        codemap::emit_error(none, msg);
         fail;
     }
     fn span_err(sp: span, msg: str) {
-        codemap::emit_error(some(sp), msg, self.parse_sess.cm);
+        codemap::emit_error(some((self.parse_sess.cm, sp)), msg);
         self.err_count += 1u;
     }
     fn err(msg: str) {
-        codemap::emit_error(none, msg, self.parse_sess.cm);
+        codemap::emit_error(none, msg);
         self.err_count += 1u;
     }
     fn has_errors() -> bool { self.err_count > 0u }
@@ -87,16 +87,16 @@ impl session for session {
         }
     }
     fn span_warn(sp: span, msg: str) {
-        codemap::emit_warning(some(sp), msg, self.parse_sess.cm);
+        codemap::emit_warning(some((self.parse_sess.cm, sp)), msg);
     }
     fn warn(msg: str) {
-        codemap::emit_warning(none, msg, self.parse_sess.cm);
+        codemap::emit_warning(none, msg);
     }
     fn span_note(sp: span, msg: str) {
-        codemap::emit_note(some(sp), msg, self.parse_sess.cm);
+        codemap::emit_note(some((self.parse_sess.cm, sp)), msg);
     }
     fn note(msg: str) {
-        codemap::emit_note(none, msg, self.parse_sess.cm);
+        codemap::emit_note(none, msg);
     }
     fn span_bug(sp: span, msg: str) -> ! {
         self.span_fatal(sp, #fmt["internal compiler error %s", msg]);

src/comp/syntax/codemap.rs

@@ -136,26 +136,28 @@ fn print_diagnostic(topic: str, t: diagnostictype, msg: str) {
     io::stdout().write_str(#fmt[" %s\n", msg]);
 }
 
-fn emit_diagnostic(sp: option::t<span>, msg: str, t: diagnostictype,
-                   cm: codemap) {
+fn emit_diagnostic(cmsp: option<(codemap, span)>, msg: str,
+                   t: diagnostictype) {
     let ss = "";
     let maybe_lines: option::t<@file_lines> = none;
-    alt sp {
-      some(ssp) {
-        ss = span_to_str(ssp, cm);
-        maybe_lines = some(span_to_lines(ssp, cm));
+    alt cmsp {
+      some((cm, sp)) {
+        ss = span_to_str(sp, cm);
+        maybe_lines = some(span_to_lines(sp, cm));
       }
       none. { }
     }
     print_diagnostic(ss, t, msg);
-    maybe_highlight_lines(sp, cm, maybe_lines);
+    maybe_highlight_lines(cmsp, maybe_lines);
 }
 
-fn maybe_highlight_lines(sp: option::t<span>, cm: codemap,
+fn maybe_highlight_lines(cmsp: option<(codemap, span)>,
                          maybe_lines: option::t<@file_lines>) {
 
     alt maybe_lines {
       some(lines) {
+        let (cm, sp) = option::get(cmsp);
+
         // If we're not looking at a real file then we can't re-open it to
         // pull out the lines
         if lines.name == "-" { ret; }
@@ -165,7 +167,7 @@ fn maybe_highlight_lines(sp: option::t<span>, cm: codemap,
         let file = alt io::read_whole_file_str(lines.name) {
           result::ok(file) { file }
           result::err(e) {
-            emit_error(none, e, cm);
+            emit_error(none, e);
             fail;
           }
         };
@@ -199,7 +201,7 @@ fn maybe_highlight_lines(sp: option::t<span>, cm: codemap,
 
         // If there's one line at fault we can easily point to the problem
         if vec::len(lines.lines) == 1u {
-            let lo = lookup_char_pos(cm, option::get(sp).lo);
+            let lo = lookup_char_pos(cm, sp.lo);
             let digits = 0u;
             let num = (lines.lines[0] + 1u) / 10u;
 
@@ -212,7 +214,7 @@ fn maybe_highlight_lines(sp: option::t<span>, cm: codemap,
             while left > 0u { str::push_char(s, ' '); left -= 1u; }
 
             s += "^";
-            let hi = lookup_char_pos(cm, option::get(sp).hi);
+            let hi = lookup_char_pos(cm, sp.hi);
             if hi.col != lo.col {
                 // the ^ already takes up one space
                 let width = hi.col - lo.col - 1u;
@@ -225,14 +227,14 @@ fn maybe_highlight_lines(sp: option::t<span>, cm: codemap,
     }
 }
 
-fn emit_warning(sp: option::t<span>, msg: str, cm: codemap) {
-    emit_diagnostic(sp, msg, warning, cm);
+fn emit_warning(cmsp: option<(codemap, span)>, msg: str) {
+    emit_diagnostic(cmsp, msg, warning);
 }
-fn emit_error(sp: option::t<span>, msg: str, cm: codemap) {
-    emit_diagnostic(sp, msg, error, cm);
+fn emit_error(cmsp: option<(codemap, span)>, msg: str) {
+    emit_diagnostic(cmsp, msg, error);
 }
-fn emit_note(sp: option::t<span>, msg: str, cm: codemap) {
-    emit_diagnostic(sp, msg, note, cm);
+fn emit_note(cmsp: option<(codemap, span)>, msg: str) {
+    emit_diagnostic(cmsp, msg, note);
 }
 
 type file_lines = {name: str, lines: [uint]};

src/comp/syntax/parse/lexer.rs

@@ -47,8 +47,8 @@ impl reader for reader {
         } else { self.curr = -1 as char; }
     }
     fn err(m: str) {
-        codemap::emit_error(some(ast_util::mk_sp(self.chpos, self.chpos)),
-                            m, self.cm);
+        codemap::emit_error(
+            some((self.cm, ast_util::mk_sp(self.chpos, self.chpos))), m);
     }
 }
 

src/comp/syntax/parse/parser.rs

@@ -71,11 +71,11 @@ impl parser for parser {
         self.span_fatal(self.span, m);
     }
     fn span_fatal(sp: span, m: str) -> ! {
-        codemap::emit_error(some(sp), m, self.sess.cm);
+        codemap::emit_error(some((self.sess.cm, sp)), m);
         fail;
     }
     fn warn(m: str) {
-        codemap::emit_warning(some(self.span), m, self.sess.cm);
+        codemap::emit_warning(some((self.sess.cm, self.span)), m);
     }
     fn get_str(i: token::str_num) -> str {
         interner::get(*self.reader.interner, i)
@@ -92,7 +92,7 @@ fn new_parser_from_file(sess: parse_sess, cfg: ast::crate_cfg, path: str,
         src
       }
       result::err(e) {
-        codemap::emit_error(none, e, sess.cm);
+        codemap::emit_error(none, e);
         fail;
       }
     };
@@ -2525,8 +2525,7 @@ fn parse_crate_from_file(input: str, cfg: ast::crate_cfg, sess: parse_sess) ->
     } else if str::ends_with(input, ".rs") {
         parse_crate_from_source_file(input, cfg, sess)
     } else {
-        codemap::emit_error(none, "unknown input file type: " + input,
-                            sess.cm);
+        codemap::emit_error(none, "unknown input file type: " + input);
         fail
     }
 }