mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rustc: Extract driver::diagnostic from syntax::codemap

Browse Source
This commit is contained in:
Brian Anderson 2012-01-13 16:05:58 -08:00
parent bb1e8d2339
commit ced0aa13d3
7 changed files with 154 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

137
src/comp/driver/diagnostic.rs Normal file
View File

@ -0,0 +1,137 @@
import std::{io, term};
import io::writer_util;
import syntax::codemap;
import codemap::span;
export diagnostictype, warning, error, note;
export print_diagnostic, emit_warning, emit_error, emit_note;
tag diagnostictype {
warning;
error;
note;
}
fn diagnosticstr(t: diagnostictype) -> str {
alt t {
warning. { "warning" }
error. { "error" }
note. { "note" }
}
}
fn diagnosticcolor(t: diagnostictype) -> u8 {
alt t {
warning. { term::color_bright_yellow }
error. { term::color_bright_red }
note. { term::color_bright_green }
}
}
fn print_diagnostic(topic: str, t: diagnostictype, msg: str) {
if str::is_not_empty(topic) {
io::stdout().write_str(#fmt["%s ", topic]);
}
if term::color_supported() {
term::fg(io::stdout(), diagnosticcolor(t));
}
io::stdout().write_str(#fmt["%s:", diagnosticstr(t)]);
if term::color_supported() {
term::reset(io::stdout());
}
io::stdout().write_str(#fmt[" %s\n", msg]);
}
fn emit_diagnostic(cmsp: option<(codemap::codemap, span)>,
msg: str, t: diagnostictype) {
alt cmsp {
some((cm, sp)) {
let ss = codemap::span_to_str(sp, cm);
let lines = codemap::span_to_lines(sp, cm);
print_diagnostic(ss, t, msg);
highlight_lines(cm, sp, lines);
}
none. {
print_diagnostic("", t, msg);
}
}
}
fn highlight_lines(cm: codemap::codemap, sp: span,
lines: @codemap::file_lines) {
// 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; }
// FIXME: reading in the entire file is the worst possible way to
// get access to the necessary lines.
let file = alt io::read_whole_file_str(lines.name) {
result::ok(file) { file }
result::err(e) {
emit_error(none, e);
fail;
}
};
let fm = codemap::get_filemap(cm, lines.name);
// arbitrarily only print up to six lines of the error
let max_lines = 6u;
let elided = false;
let display_lines = lines.lines;
if vec::len(display_lines) > max_lines {
display_lines = vec::slice(display_lines, 0u, max_lines);
elided = true;
}
// Print the offending lines
for line: uint in display_lines {
io::stdout().write_str(#fmt["%s:%u ", fm.name, line + 1u]);
let s = codemap::get_line(fm, line as int, file);
if !str::ends_with(s, "\n") { s += "\n"; }
io::stdout().write_str(s);
}
if elided {
let last_line = display_lines[vec::len(display_lines) - 1u];
let s = #fmt["%s:%u ", fm.name, last_line + 1u];
let indent = str::char_len(s);
let out = "";
while indent > 0u { out += " "; indent -= 1u; }
out += "...\n";
io::stdout().write_str(out);
}
// If there's one line at fault we can easily point to the problem
if vec::len(lines.lines) == 1u {
let lo = codemap::lookup_char_pos(cm, sp.lo);
let digits = 0u;
let num = (lines.lines[0] + 1u) / 10u;
// how many digits must be indent past?
while num > 0u { num /= 10u; digits += 1u; }
// indent past |name:## | and the 0-offset column location
let left = str::char_len(fm.name) + digits + lo.col + 3u;
let s = "";
while left > 0u { str::push_char(s, ' '); left -= 1u; }
s += "^";
let hi = codemap::lookup_char_pos(cm, sp.hi);
if hi.col != lo.col {
// the ^ already takes up one space
let width = hi.col - lo.col - 1u;
while width > 0u { str::push_char(s, '~'); width -= 1u; }
}
io::stdout().write_str(s + "\n");
}
}
fn emit_warning(cmsp: option<(codemap::codemap, span)>, msg: str) {
emit_diagnostic(cmsp, msg, warning);
}
fn emit_error(cmsp: option<(codemap::codemap, span)>, msg: str) {
emit_diagnostic(cmsp, msg, error);
}
fn emit_note(cmsp: option<(codemap::codemap, span)>, msg: str) {
emit_diagnostic(cmsp, msg, note);
}

2
src/comp/driver/driver.rs
View File

@ -580,7 +580,7 @@ fn build_output_filenames(ifile: str,
}
fn early_error(msg: str) -> ! {
codemap::print_diagnostic("", codemap::error, msg);
diagnostic::print_diagnostic("", diagnostic::error, msg);
fail;
}

16
src/comp/driver/session.rs
View File

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

1
src/comp/rustc.rc
View File

@ -123,6 +123,7 @@ mod metadata {
mod driver {
mod driver;
mod session;
mod diagnostic;
}
mod util {

132
src/comp/syntax/codemap.rs
View File

@ -1,6 +1,4 @@
import core::{vec, uint, str, option, result};
import std::{term, io};
import io::writer_util;
import option::{some, none};
type filename = str;
@ -100,136 +98,6 @@ fn span_to_str(sp: span, cm: codemap) -> str {
ret res;
}
tag diagnostictype {
warning;
error;
note;
}
fn diagnosticstr(t: diagnostictype) -> str {
alt t {
warning. { "warning" }
error. { "error" }
note. { "note" }
}
}
fn diagnosticcolor(t: diagnostictype) -> u8 {
alt t {
warning. { term::color_bright_yellow }
error. { term::color_bright_red }
note. { term::color_bright_green }
}
}
fn print_diagnostic(topic: str, t: diagnostictype, msg: str) {
if str::is_not_empty(topic) {
io::stdout().write_str(#fmt["%s ", topic]);
}
if term::color_supported() {
term::fg(io::stdout(), diagnosticcolor(t));
}
io::stdout().write_str(#fmt["%s:", diagnosticstr(t)]);
if term::color_supported() {
term::reset(io::stdout());
}
io::stdout().write_str(#fmt[" %s\n", msg]);
}
fn emit_diagnostic(cmsp: option<(codemap, span)>, msg: str,
t: diagnostictype) {
alt cmsp {
some((cm, sp)) {
let ss = span_to_str(sp, cm);
let lines = span_to_lines(sp, cm);
print_diagnostic(ss, t, msg);
highlight_lines(cm, sp, lines);
}
none. {
print_diagnostic("", t, msg);
}
}
}
fn highlight_lines(cm: codemap, sp: span,
lines: @file_lines) {
// 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; }
// FIXME: reading in the entire file is the worst possible way to
// get access to the necessary lines.
let file = alt io::read_whole_file_str(lines.name) {
result::ok(file) { file }
result::err(e) {
emit_error(none, e);
fail;
}
};
let fm = get_filemap(cm, lines.name);
// arbitrarily only print up to six lines of the error
let max_lines = 6u;
let elided = false;
let display_lines = lines.lines;
if vec::len(display_lines) > max_lines {
display_lines = vec::slice(display_lines, 0u, max_lines);
elided = true;
}
// Print the offending lines
for line: uint in display_lines {
io::stdout().write_str(#fmt["%s:%u ", fm.name, line + 1u]);
let s = get_line(fm, line as int, file);
if !str::ends_with(s, "\n") { s += "\n"; }
io::stdout().write_str(s);
}
if elided {
let last_line = display_lines[vec::len(display_lines) - 1u];
let s = #fmt["%s:%u ", fm.name, last_line + 1u];
let indent = str::char_len(s);
let out = "";
while indent > 0u { out += " "; indent -= 1u; }
out += "...\n";
io::stdout().write_str(out);
}
// 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, sp.lo);
let digits = 0u;
let num = (lines.lines[0] + 1u) / 10u;
// how many digits must be indent past?
while num > 0u { num /= 10u; digits += 1u; }
// indent past |name:## | and the 0-offset column location
let left = str::char_len(fm.name) + digits + lo.col + 3u;
let s = "";
while left > 0u { str::push_char(s, ' '); left -= 1u; }
s += "^";
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;
while width > 0u { str::push_char(s, '~'); width -= 1u; }
}
io::stdout().write_str(s + "\n");
}
}
fn emit_warning(cmsp: option<(codemap, span)>, msg: str) {
emit_diagnostic(cmsp, msg, warning);
}
fn emit_error(cmsp: option<(codemap, span)>, msg: str) {
emit_diagnostic(cmsp, msg, error);
}
fn emit_note(cmsp: option<(codemap, span)>, msg: str) {
emit_diagnostic(cmsp, msg, note);
}
type file_lines = {name: str, lines: [uint]};
fn span_to_lines(sp: span, cm: codemap::codemap) -> @file_lines {

3
src/comp/syntax/parse/lexer.rs
View File

@ -6,6 +6,7 @@
import util::interner;
import util::interner::intern;
import codemap;
import driver::diagnostic;
type reader = @{
cm: codemap::codemap,
@ -47,7 +48,7 @@ fn bump() {
} else { self.curr = -1 as char; }
}
fn err(m: str) {
codemap::emit_error(
diagnostic::emit_error(
some((self.cm, ast_util::mk_sp(self.chpos, self.chpos))), m);
}
}

9
src/comp/syntax/parse/parser.rs
View File

@ -10,6 +10,7 @@
import ast::{node_id, spanned};
import front::attr;
import lexer::reader;
import driver::diagnostic;
tag restriction {
UNRESTRICTED;
@ -71,11 +72,11 @@ fn fatal(m: str) -> ! {
self.span_fatal(self.span, m);
}
fn span_fatal(sp: span, m: str) -> ! {
codemap::emit_error(some((self.sess.cm, sp)), m);
diagnostic::emit_error(some((self.sess.cm, sp)), m);
fail;
}
fn warn(m: str) {
codemap::emit_warning(some((self.sess.cm, self.span)), m);
diagnostic::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 +93,7 @@ fn new_parser_from_file(sess: parse_sess, cfg: ast::crate_cfg, path: str,
src
}
result::err(e) {
codemap::emit_error(none, e);
diagnostic::emit_error(none, e);
fail;
}
};
@ -2525,7 +2526,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);
diagnostic::emit_error(none, "unknown input file type: " + input);
fail
}
}