Skip to content

Commit 1949af4

Browse files
pcwaltonpcwalton
committed
---
yaml --- r: 13765 b: refs/heads/try c: 9ecd5ee h: refs/heads/master i: 13763: cd92339 v: v3
1 parent b9515a9 commit 1949af4

File tree

10 files changed

+115
-81
lines changed

10 files changed

+115
-81
lines changed

‎[refs]

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2,5 +2,5 @@
22
refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
33
refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
44
refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
5-
refs/heads/try: 4d096a8c860b0f7ff0933a8606f6e39398aebaae
5+
refs/heads/try: 9ecd5ee81d642fed89246924b240bf3d3b0b8e64
66
refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

‎branches/try/src/cargo/cargo.rs

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -100,10 +100,11 @@ fn load_link(mis: [@ast::meta_item]) -> (option::t<str>,
100100

101101
fn load_pkg(filename: str) -> option::t<pkg> {
102102
let cm = codemap::new_codemap();
103+
let handler = diagnostic::mk_handler(none);
103104
let sess = @{
104105
cm: cm,
105106
mutable next_id: 1,
106-
diagnostic: diagnostic::mk_handler(cm, none),
107+
span_diagnostic: diagnostic::mk_span_handler(handler, cm),
107108
mutable chpos: 0u,
108109
mutable byte_pos: 0u
109110
};

‎branches/try/src/comp/driver/diagnostic.rs

Lines changed: 60 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -5,51 +5,82 @@ import codemap::span;
55

66
export emitter, emit;
77
export level, fatal, error, warning, note;
8-
export handler, mk_handler;
8+
export span_handler, handler, mk_span_handler, mk_handler;
9+
export codemap_span_handler, codemap_handler;
910
export ice_msg;
1011

1112
type emitter = fn@(cmsp: option<(codemap::codemap, span)>,
1213
msg: str, lvl: level);
1314

1415

15-
iface handler {
16+
iface span_handler {
1617
fn span_fatal(sp: span, msg: str) -> !;
17-
fn fatal(msg: str) -> !;
1818
fn span_err(sp: span, msg: str);
19+
fn span_warn(sp: span, msg: str);
20+
fn span_note(sp: span, msg: str);
21+
fn span_bug(sp: span, msg: str) -> !;
22+
fn span_unimpl(sp: span, msg: str) -> !;
23+
fn handler() -> handler;
24+
}
25+
26+
iface handler {
27+
fn fatal(msg: str) -> !;
1928
fn err(msg: str);
29+
fn bump_err_count();
2030
fn has_errors() -> bool;
2131
fn abort_if_errors();
22-
fn span_warn(sp: span, msg: str);
2332
fn warn(msg: str);
24-
fn span_note(sp: span, msg: str);
2533
fn note(msg: str);
26-
fn span_bug(sp: span, msg: str) -> !;
2734
fn bug(msg: str) -> !;
28-
fn span_unimpl(sp: span, msg: str) -> !;
2935
fn unimpl(msg: str) -> !;
36+
fn emit(cmsp: option<(codemap::codemap, span)>, msg: str, lvl: level);
3037
}
3138

32-
type codemap_t = @{
33-
cm: codemap::codemap,
39+
type handler_t = @{
3440
mutable err_count: uint,
35-
emit: emitter
41+
_emit: emitter
42+
};
43+
44+
type codemap_t = @{
45+
handler: handler,
46+
cm: codemap::codemap
3647
};
3748

38-
impl codemap_handler of handler for codemap_t {
49+
impl codemap_span_handler of span_handler for codemap_t {
3950
fn span_fatal(sp: span, msg: str) -> ! {
40-
self.emit(some((self.cm, sp)), msg, fatal);
51+
self.handler.emit(some((self.cm, sp)), msg, fatal);
4152
fail;
4253
}
54+
fn span_err(sp: span, msg: str) {
55+
self.handler.emit(some((self.cm, sp)), msg, error);
56+
self.handler.bump_err_count();
57+
}
58+
fn span_warn(sp: span, msg: str) {
59+
self.handler.emit(some((self.cm, sp)), msg, warning);
60+
}
61+
fn span_note(sp: span, msg: str) {
62+
self.handler.emit(some((self.cm, sp)), msg, note);
63+
}
64+
fn span_bug(sp: span, msg: str) -> ! {
65+
self.span_fatal(sp, ice_msg(msg));
66+
}
67+
fn span_unimpl(sp: span, msg: str) -> ! {
68+
self.span_bug(sp, "unimplemented " + msg);
69+
}
70+
fn handler() -> handler {
71+
self.handler
72+
}
73+
}
74+
75+
impl codemap_handler of handler for handler_t {
4376
fn fatal(msg: str) -> ! {
44-
self.emit(none, msg, fatal);
77+
self._emit(none, msg, fatal);
4578
fail;
4679
}
47-
fn span_err(sp: span, msg: str) {
48-
self.emit(some((self.cm, sp)), msg, error);
49-
self.err_count += 1u;
50-
}
5180
fn err(msg: str) {
52-
self.emit(none, msg, error);
81+
self._emit(none, msg, error);
82+
}
83+
fn bump_err_count() {
5384
self.err_count += 1u;
5485
}
5586
fn has_errors() -> bool { self.err_count > 0u }
@@ -58,36 +89,30 @@ impl codemap_handler of handler for codemap_t {
5889
self.fatal("aborting due to previous errors");
5990
}
6091
}
61-
fn span_warn(sp: span, msg: str) {
62-
self.emit(some((self.cm, sp)), msg, warning);
63-
}
6492
fn warn(msg: str) {
65-
self.emit(none, msg, warning);
66-
}
67-
fn span_note(sp: span, msg: str) {
68-
self.emit(some((self.cm, sp)), msg, note);
93+
self._emit(none, msg, warning);
6994
}
7095
fn note(msg: str) {
71-
self.emit(none, msg, note);
72-
}
73-
fn span_bug(sp: span, msg: str) -> ! {
74-
self.span_fatal(sp, ice_msg(msg));
96+
self._emit(none, msg, note);
7597
}
7698
fn bug(msg: str) -> ! {
7799
self.fatal(ice_msg(msg));
78100
}
79-
fn span_unimpl(sp: span, msg: str) -> ! {
80-
self.span_bug(sp, "unimplemented " + msg);
81-
}
82101
fn unimpl(msg: str) -> ! { self.bug("unimplemented " + msg); }
102+
fn emit(cmsp: option<(codemap::codemap, span)>, msg: str, lvl: level) {
103+
self._emit(cmsp, msg, lvl);
104+
}
83105
}
84106

85107
fn ice_msg(msg: str) -> str {
86108
#fmt["internal compiler error %s", msg]
87109
}
88110

89-
fn mk_handler(cm: codemap::codemap,
90-
emitter: option<emitter>) -> handler {
111+
fn mk_span_handler(handler: handler, cm: codemap::codemap) -> span_handler {
112+
@{ handler: handler, cm: cm } as span_handler
113+
}
114+
115+
fn mk_handler(emitter: option<emitter>) -> handler {
91116

92117
let emit = alt emitter {
93118
some(e) { e }
@@ -101,9 +126,8 @@ fn mk_handler(cm: codemap::codemap,
101126
};
102127

103128
@{
104-
cm: cm,
105129
mutable err_count: 0u,
106-
emit: emit
130+
_emit: emit
107131
} as handler
108132
}
109133

‎branches/try/src/comp/driver/driver.rs

Lines changed: 6 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -299,7 +299,7 @@ fn pretty_print_input(sess: session, cfg: ast::crate_cfg, input: str,
299299
}
300300
ppm_expanded | ppm_normal {}
301301
}
302-
pprust::print_crate(sess.codemap, sess.diagnostic, crate, input,
302+
pprust::print_crate(sess.codemap, sess.span_diagnostic, crate, input,
303303
io::string_reader(src), io::stdout(), ann);
304304
}
305305

@@ -481,21 +481,23 @@ fn build_session(sopts: @session::options, input: str,
481481
sopts.addl_lib_search_paths);
482482
let codemap = codemap::new_codemap();
483483
let diagnostic_handler =
484-
diagnostic::mk_handler(codemap, some(demitter));
484+
diagnostic::mk_handler(some(demitter));
485+
let span_diagnostic_handler =
486+
diagnostic::mk_span_handler(diagnostic_handler, codemap);
485487
@{targ_cfg: target_cfg,
486488
opts: sopts,
487489
cstore: cstore,
488490
parse_sess: @{
489491
cm: codemap,
490492
mutable next_id: 1,
491-
diagnostic: diagnostic_handler,
493+
span_diagnostic: span_diagnostic_handler,
492494
mutable chpos: 0u,
493495
mutable byte_pos: 0u
494496
},
495497
codemap: codemap,
496498
// For a library crate, this is always none
497499
mutable main_fn: none,
498-
diagnostic: diagnostic_handler,
500+
span_diagnostic: span_diagnostic_handler,
499501
filesearch: filesearch,
500502
mutable building_library: false,
501503
working_dir: fs::dirname(input)}

‎branches/try/src/comp/driver/session.rs

Lines changed: 15 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -60,53 +60,53 @@ type session = @{targ_cfg: @config,
6060
codemap: codemap::codemap,
6161
// For a library crate, this is always none
6262
mutable main_fn: option::t<node_id>,
63-
diagnostic: diagnostic::handler,
63+
span_diagnostic: diagnostic::span_handler,
6464
filesearch: filesearch::filesearch,
6565
mutable building_library: bool,
6666
working_dir: str};
6767

6868
impl session for session {
6969
fn span_fatal(sp: span, msg: str) -> ! {
70-
self.diagnostic.span_fatal(sp, msg)
70+
self.span_diagnostic.span_fatal(sp, msg)
7171
}
7272
fn fatal(msg: str) -> ! {
73-
self.diagnostic.fatal(msg)
73+
self.span_diagnostic.handler().fatal(msg)
7474
}
7575
fn span_err(sp: span, msg: str) {
76-
self.diagnostic.span_err(sp, msg)
76+
self.span_diagnostic.span_err(sp, msg)
7777
}
7878
fn err(msg: str) {
79-
self.diagnostic.err(msg)
79+
self.span_diagnostic.handler().err(msg)
8080
}
8181
fn has_errors() -> bool {
82-
self.diagnostic.has_errors()
82+
self.span_diagnostic.handler().has_errors()
8383
}
8484
fn abort_if_errors() {
85-
self.diagnostic.abort_if_errors()
85+
self.span_diagnostic.handler().abort_if_errors()
8686
}
8787
fn span_warn(sp: span, msg: str) {
88-
self.diagnostic.span_warn(sp, msg)
88+
self.span_diagnostic.span_warn(sp, msg)
8989
}
9090
fn warn(msg: str) {
91-
self.diagnostic.warn(msg)
91+
self.span_diagnostic.handler().warn(msg)
9292
}
9393
fn span_note(sp: span, msg: str) {
94-
self.diagnostic.span_note(sp, msg)
94+
self.span_diagnostic.span_note(sp, msg)
9595
}
9696
fn note(msg: str) {
97-
self.diagnostic.note(msg)
97+
self.span_diagnostic.handler().note(msg)
9898
}
9999
fn span_bug(sp: span, msg: str) -> ! {
100-
self.diagnostic.span_bug(sp, msg)
100+
self.span_diagnostic.span_bug(sp, msg)
101101
}
102102
fn bug(msg: str) -> ! {
103-
self.diagnostic.bug(msg)
103+
self.span_diagnostic.handler().bug(msg)
104104
}
105105
fn span_unimpl(sp: span, msg: str) -> ! {
106-
self.diagnostic.span_unimpl(sp, msg)
106+
self.span_diagnostic.span_unimpl(sp, msg)
107107
}
108108
fn unimpl(msg: str) -> ! {
109-
self.diagnostic.unimpl(msg)
109+
self.span_diagnostic.handler().unimpl(msg)
110110
}
111111
fn next_node_id() -> ast::node_id {
112112
ret syntax::parse::parser::next_node_id(self.parse_sess);

‎branches/try/src/comp/syntax/parse/lexer.rs

Lines changed: 7 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -10,7 +10,7 @@ import driver::diagnostic;
1010

1111
type reader = @{
1212
cm: codemap::codemap,
13-
diagnostic: diagnostic::handler,
13+
span_diagnostic: diagnostic::span_handler,
1414
src: str,
1515
len: uint,
1616
mutable col: uint,
@@ -49,17 +49,18 @@ impl reader for reader {
4949
} else { self.curr = -1 as char; }
5050
}
5151
fn fatal(m: str) -> ! {
52-
self.diagnostic.span_fatal(
52+
self.span_diagnostic.span_fatal(
5353
ast_util::mk_sp(self.chpos, self.chpos),
5454
m)
5555
}
5656
}
5757

5858
fn new_reader(cm: codemap::codemap,
59-
diagnostic: diagnostic::handler,
59+
span_diagnostic: diagnostic::span_handler,
6060
src: str, filemap: codemap::filemap,
6161
itr: @interner::interner<str>) -> reader {
62-
let r = @{cm: cm, diagnostic: diagnostic,
62+
let r = @{cm: cm,
63+
span_diagnostic: span_diagnostic,
6364
src: src, len: str::byte_len(src),
6465
mutable col: 0u, mutable pos: 0u, mutable curr: -1 as char,
6566
mutable chpos: filemap.start_pos.ch, mutable strs: [],
@@ -667,13 +668,13 @@ fn is_lit(t: token::token) -> bool {
667668
type lit = {lit: str, pos: uint};
668669

669670
fn gather_comments_and_literals(cm: codemap::codemap,
670-
diagnostic: diagnostic::handler,
671+
span_diagnostic: diagnostic::span_handler,
671672
path: str,
672673
srdr: io::reader) ->
673674
{cmnts: [cmnt], lits: [lit]} {
674675
let src = str::unsafe_from_bytes(srdr.read_whole_stream());
675676
let itr = @interner::mk::<str>(str::hash, str::eq);
676-
let rdr = new_reader(cm, diagnostic, src,
677+
let rdr = new_reader(cm, span_diagnostic, src,
677678
codemap::new_filemap(path, 0u, 0u), itr);
678679
let comments: [cmnt] = [];
679680
let literals: [lit] = [];

‎branches/try/src/comp/syntax/parse/parser.rs

Lines changed: 11 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -24,7 +24,7 @@ enum file_type { CRATE_FILE, SOURCE_FILE, }
2424
type parse_sess = @{
2525
cm: codemap::codemap,
2626
mutable next_id: node_id,
27-
diagnostic: diagnostic::handler,
27+
span_diagnostic: diagnostic::span_handler,
2828
// these two must be kept up to date
2929
mutable chpos: uint,
3030
mutable byte_pos: uint
@@ -78,13 +78,13 @@ impl parser for parser {
7878
ret self.buffer[distance - 1u].tok;
7979
}
8080
fn fatal(m: str) -> ! {
81-
self.sess.diagnostic.span_fatal(self.span, m)
81+
self.sess.span_diagnostic.span_fatal(self.span, m)
8282
}
8383
fn span_fatal(sp: span, m: str) -> ! {
84-
self.sess.diagnostic.span_fatal(sp, m)
84+
self.sess.span_diagnostic.span_fatal(sp, m)
8585
}
8686
fn warn(m: str) {
87-
self.sess.diagnostic.span_warn(self.span, m)
87+
self.sess.span_diagnostic.span_warn(self.span, m)
8888
}
8989
fn get_str(i: token::str_num) -> str {
9090
interner::get(*self.reader.interner, i)
@@ -101,14 +101,14 @@ fn new_parser_from_file(sess: parse_sess, cfg: ast::crate_cfg, path: str,
101101
src
102102
}
103103
result::err(e) {
104-
sess.diagnostic.fatal(e)
104+
sess.span_diagnostic.handler().fatal(e)
105105
}
106106
};
107107
let filemap = codemap::new_filemap(path, sess.chpos, sess.byte_pos);
108108
sess.cm.files += [filemap];
109109
let itr = @interner::mk(str::hash, str::eq);
110-
let rdr = lexer::new_reader(sess.cm, sess.diagnostic,
111-
src, filemap, itr);
110+
let rdr = lexer::new_reader(sess.cm, sess.span_diagnostic, src, filemap,
111+
itr);
112112
ret new_parser(sess, cfg, rdr, ftype);
113113
}
114114

@@ -118,8 +118,8 @@ fn new_parser_from_source_str(sess: parse_sess, cfg: ast::crate_cfg,
118118
let filemap = codemap::new_filemap(name, sess.chpos, sess.byte_pos);
119119
sess.cm.files += [filemap];
120120
let itr = @interner::mk(str::hash, str::eq);
121-
let rdr = lexer::new_reader(sess.cm, sess.diagnostic,
122-
source, filemap, itr);
121+
let rdr = lexer::new_reader(sess.cm, sess.span_diagnostic, source,
122+
filemap, itr);
123123
ret new_parser(sess, cfg, rdr, ftype);
124124
}
125125

@@ -2628,7 +2628,8 @@ fn parse_crate_from_file(input: str, cfg: ast::crate_cfg, sess: parse_sess) ->
26282628
} else if str::ends_with(input, ".rs") {
26292629
parse_crate_from_source_file(input, cfg, sess)
26302630
} else {
2631-
sess.diagnostic.fatal("unknown input file type: " + input)
2631+
sess.span_diagnostic.handler().fatal("unknown input file type: " +
2632+
input)
26322633
}
26332634
}
26342635

0 commit comments

Comments
 (0)