Skip to content

Commit 10c9266

Browse files
pcwaltonpcwalton
committed
rustc: Number everything with an annotation
1 parent 4b5b96c commit 10c9266

File tree

9 files changed

+193
-175
lines changed

9 files changed

+193
-175
lines changed

‎src/comp/front/ast.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,7 @@ type ty_param = ident;
2222

2323
// Annotations added during successive passes.
2424
tag ann {
25-
ann_none;
25+
ann_none(uint);
2626
ann_type(middle.ty.t,
2727
Option.t[vec[middle.ty.t]], /* ty param substs */
2828
Option.t[@ts_ann]); /* pre- and postcondition for typestate */

‎src/comp/front/extenv.rs

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -29,10 +29,10 @@ fn expand_syntax_ext(parser.parser p,
2929
auto var = expr_to_str(p, args.(0));
3030
alt (GenericOS.getenv(var)) {
3131
case (Option.none[str]) {
32-
ret make_new_str(sp, "");
32+
ret make_new_str(p, sp, "");
3333
}
3434
case (Option.some[str](?s)) {
35-
ret make_new_str(sp, s);
35+
ret make_new_str(p, sp, s);
3636
}
3737
}
3838
}
@@ -54,15 +54,15 @@ fn expr_to_str(parser.parser p,
5454
fail;
5555
}
5656

57-
fn make_new_lit(common.span sp, ast.lit_ lit) -> @ast.expr {
57+
fn make_new_lit(parser.parser p, common.span sp, ast.lit_ lit) -> @ast.expr {
5858
auto sp_lit = @rec(node=lit, span=sp);
59-
auto expr = ast.expr_lit(sp_lit, ast.ann_none);
59+
auto expr = ast.expr_lit(sp_lit, p.get_ann());
6060
ret @rec(node=expr, span=sp);
6161
}
6262

63-
fn make_new_str(common.span sp, str s) -> @ast.expr {
63+
fn make_new_str(parser.parser p, common.span sp, str s) -> @ast.expr {
6464
auto lit = ast.lit_str(s);
65-
ret make_new_lit(sp, lit);
65+
ret make_new_lit(p, sp, lit);
6666
}
6767

6868
//

‎src/comp/front/extfmt.rs

Lines changed: 74 additions & 65 deletions
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,7 @@
44
* compiler syntax extension plugin interface.
55
*/
66

7+
import front.parser.parser;
78
import util.common;
89

910
import std.Str;
@@ -45,11 +46,12 @@ import std.ExtFmt.CT.parse_fmt_string;
4546

4647
export expand_syntax_ext;
4748

48-
// FIXME: Need to thread parser through here to handle errors correctly
49-
fn expand_syntax_ext(vec[@ast.expr] args,
49+
fn expand_syntax_ext(parser p,
50+
vec[@ast.expr] args,
5051
Option.t[str] body) -> @ast.expr {
5152

5253
if (Vec.len[@ast.expr](args) == 0u) {
54+
// FIXME: Handle error correctly.
5355
log_err "malformed #fmt call";
5456
fail;
5557
}
@@ -62,7 +64,7 @@ fn expand_syntax_ext(vec[@ast.expr] args,
6264
auto pieces = parse_fmt_string(fmt);
6365
auto args_len = Vec.len[@ast.expr](args);
6466
auto fmt_args = Vec.slice[@ast.expr](args, 1u, args_len - 1u);
65-
ret pieces_to_expr(pieces, args);
67+
ret pieces_to_expr(p, pieces, args);
6668
}
6769

6870
fn expr_to_str(@ast.expr expr) -> str {
@@ -75,6 +77,7 @@ fn expr_to_str(@ast.expr expr) -> str {
7577
}
7678
}
7779
}
80+
// FIXME: Handle error correctly.
7881
log_err "malformed #fmt call";
7982
fail;
8083
}
@@ -83,59 +86,62 @@ fn expr_to_str(@ast.expr expr) -> str {
8386
// be factored out in common with other code that builds expressions.
8487
// FIXME: Probably should be using the parser's span functions
8588
// FIXME: Cleanup the naming of these functions
86-
fn pieces_to_expr(vec[piece] pieces, vec[@ast.expr] args) -> @ast.expr {
89+
fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args)
90+
-> @ast.expr {
8791

88-
fn make_new_lit(common.span sp, ast.lit_ lit) -> @ast.expr {
92+
fn make_new_lit(parser p, common.span sp, ast.lit_ lit) -> @ast.expr {
8993
auto sp_lit = @rec(node=lit, span=sp);
90-
auto expr = ast.expr_lit(sp_lit, ast.ann_none);
94+
auto expr = ast.expr_lit(sp_lit, p.get_ann());
9195
ret @rec(node=expr, span=sp);
9296
}
9397

94-
fn make_new_str(common.span sp, str s) -> @ast.expr {
98+
fn make_new_str(parser p, common.span sp, str s) -> @ast.expr {
9599
auto lit = ast.lit_str(s);
96-
ret make_new_lit(sp, lit);
100+
ret make_new_lit(p, sp, lit);
97101
}
98102

99-
fn make_new_int(common.span sp, int i) -> @ast.expr {
103+
fn make_new_int(parser p, common.span sp, int i) -> @ast.expr {
100104
auto lit = ast.lit_int(i);
101-
ret make_new_lit(sp, lit);
105+
ret make_new_lit(p, sp, lit);
102106
}
103107

104-
fn make_new_uint(common.span sp, uint u) -> @ast.expr {
108+
fn make_new_uint(parser p, common.span sp, uint u) -> @ast.expr {
105109
auto lit = ast.lit_uint(u);
106-
ret make_new_lit(sp, lit);
110+
ret make_new_lit(p, sp, lit);
107111
}
108112

109-
fn make_add_expr(common.span sp,
113+
fn make_add_expr(parser p, common.span sp,
110114
@ast.expr lhs, @ast.expr rhs) -> @ast.expr {
111-
auto binexpr = ast.expr_binary(ast.add, lhs, rhs, ast.ann_none);
115+
auto binexpr = ast.expr_binary(ast.add, lhs, rhs, p.get_ann());
112116
ret @rec(node=binexpr, span=sp);
113117
}
114118

115-
fn make_path_expr(common.span sp, vec[ast.ident] idents) -> @ast.expr {
119+
fn make_path_expr(parser p, common.span sp, vec[ast.ident] idents)
120+
-> @ast.expr {
116121
let vec[@ast.ty] types = vec();
117122
auto path = rec(idents=idents, types=types);
118123
auto sp_path = rec(node=path, span=sp);
119-
auto pathexpr = ast.expr_path(sp_path, none[ast.def], ast.ann_none);
124+
auto pathexpr = ast.expr_path(sp_path, none[ast.def], p.get_ann());
120125
auto sp_pathexpr = @rec(node=pathexpr, span=sp);
121126
ret sp_pathexpr;
122127
}
123128

124-
fn make_vec_expr(common.span sp, vec[@ast.expr] exprs) -> @ast.expr {
125-
auto vecexpr = ast.expr_vec(exprs, ast.imm, ast.ann_none);
129+
fn make_vec_expr(parser p, common.span sp, vec[@ast.expr] exprs)
130+
-> @ast.expr {
131+
auto vecexpr = ast.expr_vec(exprs, ast.imm, p.get_ann());
126132
auto sp_vecexpr = @rec(node=vecexpr, span=sp);
127133
ret sp_vecexpr;
128134
}
129135

130-
fn make_call(common.span sp, vec[ast.ident] fn_path,
136+
fn make_call(parser p, common.span sp, vec[ast.ident] fn_path,
131137
vec[@ast.expr] args) -> @ast.expr {
132-
auto pathexpr = make_path_expr(sp, fn_path);
133-
auto callexpr = ast.expr_call(pathexpr, args, ast.ann_none);
138+
auto pathexpr = make_path_expr(p, sp, fn_path);
139+
auto callexpr = ast.expr_call(pathexpr, args, p.get_ann());
134140
auto sp_callexpr = @rec(node=callexpr, span=sp);
135141
ret sp_callexpr;
136142
}
137143

138-
fn make_rec_expr(common.span sp,
144+
fn make_rec_expr(parser p, common.span sp,
139145
vec[tup(ast.ident, @ast.expr)] fields) -> @ast.expr {
140146
let vec[ast.field] astfields = vec();
141147
for (tup(ast.ident, @ast.expr) field in fields) {
@@ -149,7 +155,7 @@ fn pieces_to_expr(vec[piece] pieces, vec[@ast.expr] args) -> @ast.expr {
149155

150156
auto recexpr = ast.expr_rec(astfields,
151157
Option.none[@ast.expr],
152-
ast.ann_none);
158+
p.get_ann());
153159
auto sp_recexpr = @rec(node=recexpr, span=sp);
154160
ret sp_recexpr;
155161
}
@@ -160,16 +166,17 @@ fn pieces_to_expr(vec[piece] pieces, vec[@ast.expr] args) -> @ast.expr {
160166
ret vec("std", "ExtFmt", "RT", ident);
161167
}
162168

163-
fn make_rt_path_expr(common.span sp, str ident) -> @ast.expr {
169+
fn make_rt_path_expr(parser p, common.span sp, str ident) -> @ast.expr {
164170
auto path = make_path_vec(ident);
165-
ret make_path_expr(sp, path);
171+
ret make_path_expr(p, sp, path);
166172
}
167173

168174
// Produces an AST expression that represents a RT.conv record,
169175
// which tells the RT.conv* functions how to perform the conversion
170-
fn make_rt_conv_expr(common.span sp, &conv cnv) -> @ast.expr {
176+
fn make_rt_conv_expr(parser p, common.span sp, &conv cnv) -> @ast.expr {
171177

172-
fn make_flags(common.span sp, vec[flag] flags) -> @ast.expr {
178+
fn make_flags(parser p, common.span sp, vec[flag] flags)
179+
-> @ast.expr {
173180
let vec[@ast.expr] flagexprs = vec();
174181
for (flag f in flags) {
175182
auto fstr;
@@ -190,29 +197,29 @@ fn pieces_to_expr(vec[piece] pieces, vec[@ast.expr] args) -> @ast.expr {
190197
fstr = "flag_alternate";
191198
}
192199
}
193-
flagexprs += vec(make_rt_path_expr(sp, fstr));
200+
flagexprs += vec(make_rt_path_expr(p, sp, fstr));
194201
}
195202

196203
// FIXME: 0-length vectors can't have their type inferred
197204
// through the rec that these flags are a member of, so
198205
// this is a hack placeholder flag
199206
if (Vec.len[@ast.expr](flagexprs) == 0u) {
200-
flagexprs += vec(make_rt_path_expr(sp, "flag_none"));
207+
flagexprs += vec(make_rt_path_expr(p, sp, "flag_none"));
201208
}
202209

203-
ret make_vec_expr(sp, flagexprs);
210+
ret make_vec_expr(p, sp, flagexprs);
204211
}
205212

206-
fn make_count(common.span sp, &count cnt) -> @ast.expr {
213+
fn make_count(parser p, common.span sp, &count cnt) -> @ast.expr {
207214
alt (cnt) {
208215
case (count_implied) {
209-
ret make_rt_path_expr(sp, "count_implied");
216+
ret make_rt_path_expr(p, sp, "count_implied");
210217
}
211218
case (count_is(?c)) {
212-
auto count_lit = make_new_int(sp, c);
219+
auto count_lit = make_new_int(p, sp, c);
213220
auto count_is_path = make_path_vec("count_is");
214221
auto count_is_args = vec(count_lit);
215-
ret make_call(sp, count_is_path, count_is_args);
222+
ret make_call(p, sp, count_is_path, count_is_args);
216223
}
217224
case (_) {
218225
log_err "not implemented";
@@ -221,7 +228,7 @@ fn pieces_to_expr(vec[piece] pieces, vec[@ast.expr] args) -> @ast.expr {
221228
}
222229
}
223230

224-
fn make_ty(common.span sp, &ty t) -> @ast.expr {
231+
fn make_ty(parser p, common.span sp, &ty t) -> @ast.expr {
225232
auto rt_type;
226233
alt (t) {
227234
case (ty_hex(?c)) {
@@ -245,41 +252,43 @@ fn pieces_to_expr(vec[piece] pieces, vec[@ast.expr] args) -> @ast.expr {
245252
}
246253
}
247254

248-
ret make_rt_path_expr(sp, rt_type);
255+
ret make_rt_path_expr(p, sp, rt_type);
249256
}
250257

251-
fn make_conv_rec(common.span sp,
258+
fn make_conv_rec(parser p,
259+
common.span sp,
252260
@ast.expr flags_expr,
253261
@ast.expr width_expr,
254262
@ast.expr precision_expr,
255263
@ast.expr ty_expr) -> @ast.expr {
256-
ret make_rec_expr(sp, vec(tup("flags", flags_expr),
257-
tup("width", width_expr),
258-
tup("precision", precision_expr),
259-
tup("ty", ty_expr)));
264+
ret make_rec_expr(p, sp, vec(tup("flags", flags_expr),
265+
tup("width", width_expr),
266+
tup("precision", precision_expr),
267+
tup("ty", ty_expr)));
260268
}
261269

262-
auto rt_conv_flags = make_flags(sp, cnv.flags);
263-
auto rt_conv_width = make_count(sp, cnv.width);
264-
auto rt_conv_precision = make_count(sp, cnv.precision);
265-
auto rt_conv_ty = make_ty(sp, cnv.ty);
266-
ret make_conv_rec(sp,
270+
auto rt_conv_flags = make_flags(p, sp, cnv.flags);
271+
auto rt_conv_width = make_count(p, sp, cnv.width);
272+
auto rt_conv_precision = make_count(p, sp, cnv.precision);
273+
auto rt_conv_ty = make_ty(p, sp, cnv.ty);
274+
ret make_conv_rec(p,
275+
sp,
267276
rt_conv_flags,
268277
rt_conv_width,
269278
rt_conv_precision,
270279
rt_conv_ty);
271280
}
272281

273-
fn make_conv_call(common.span sp, str conv_type,
282+
fn make_conv_call(parser p, common.span sp, str conv_type,
274283
&conv cnv, @ast.expr arg) -> @ast.expr {
275284
auto fname = "conv_" + conv_type;
276285
auto path = make_path_vec(fname);
277-
auto cnv_expr = make_rt_conv_expr(sp, cnv);
286+
auto cnv_expr = make_rt_conv_expr(p, sp, cnv);
278287
auto args = vec(cnv_expr, arg);
279-
ret make_call(arg.span, path, args);
288+
ret make_call(p, arg.span, path, args);
280289
}
281290

282-
fn make_new_conv(conv cnv, @ast.expr arg) -> @ast.expr {
291+
fn make_new_conv(parser p, conv cnv, @ast.expr arg) -> @ast.expr {
283292

284293
// FIXME: Extract all this validation into ExtFmt.CT
285294
fn is_signed_type(conv cnv) -> bool {
@@ -361,32 +370,32 @@ fn pieces_to_expr(vec[piece] pieces, vec[@ast.expr] args) -> @ast.expr {
361370

362371
alt (cnv.ty) {
363372
case (ty_str) {
364-
ret make_conv_call(arg.span, "str", cnv, arg);
373+
ret make_conv_call(p, arg.span, "str", cnv, arg);
365374
}
366375
case (ty_int(?sign)) {
367376
alt (sign) {
368377
case (signed) {
369-
ret make_conv_call(arg.span, "int", cnv, arg);
378+
ret make_conv_call(p, arg.span, "int", cnv, arg);
370379
}
371380
case (unsigned) {
372-
ret make_conv_call(arg.span, "uint", cnv, arg);
381+
ret make_conv_call(p, arg.span, "uint", cnv, arg);
373382
}
374383
}
375384
}
376385
case (ty_bool) {
377-
ret make_conv_call(arg.span, "bool", cnv, arg);
386+
ret make_conv_call(p, arg.span, "bool", cnv, arg);
378387
}
379388
case (ty_char) {
380-
ret make_conv_call(arg.span, "char", cnv, arg);
389+
ret make_conv_call(p, arg.span, "char", cnv, arg);
381390
}
382391
case (ty_hex(_)) {
383-
ret make_conv_call(arg.span, "uint", cnv, arg);
392+
ret make_conv_call(p, arg.span, "uint", cnv, arg);
384393
}
385394
case (ty_bits) {
386-
ret make_conv_call(arg.span, "uint", cnv, arg);
395+
ret make_conv_call(p, arg.span, "uint", cnv, arg);
387396
}
388397
case (ty_octal) {
389-
ret make_conv_call(arg.span, "uint", cnv, arg);
398+
ret make_conv_call(p, arg.span, "uint", cnv, arg);
390399
}
391400
case (_) {
392401
log_err unsupported;
@@ -489,13 +498,13 @@ fn pieces_to_expr(vec[piece] pieces, vec[@ast.expr] args) -> @ast.expr {
489498

490499
auto sp = args.(0).span;
491500
auto n = 0u;
492-
auto tmp_expr = make_new_str(sp, "");
501+
auto tmp_expr = make_new_str(p, sp, "");
493502

494-
for (piece p in pieces) {
495-
alt (p) {
503+
for (piece pc in pieces) {
504+
alt (pc) {
496505
case (piece_string(?s)) {
497-
auto s_expr = make_new_str(sp, s);
498-
tmp_expr = make_add_expr(sp, tmp_expr, s_expr);
506+
auto s_expr = make_new_str(p, sp, s);
507+
tmp_expr = make_add_expr(p, sp, tmp_expr, s_expr);
499508
}
500509
case (piece_conv(?conv)) {
501510
if (n >= Vec.len[@ast.expr](args)) {
@@ -509,8 +518,8 @@ fn pieces_to_expr(vec[piece] pieces, vec[@ast.expr] args) -> @ast.expr {
509518

510519
n += 1u;
511520
auto arg_expr = args.(n);
512-
auto c_expr = make_new_conv(conv, arg_expr);
513-
tmp_expr = make_add_expr(sp, tmp_expr, c_expr);
521+
auto c_expr = make_new_conv(p, conv, arg_expr);
522+
tmp_expr = make_add_expr(p, sp, tmp_expr, c_expr);
514523
}
515524
}
516525
}

0 commit comments

Comments
 (0)