Skip to content

Commit c88fa92

Browse files
brsonbrson
committed
rustc: Generate extension annotations from ext_ctxt instead of parser
1 parent 1d6f1dc commit c88fa92

File tree

2 files changed

+67
-65
lines changed

2 files changed

+67
-65
lines changed

‎src/comp/front/extenv.rs

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@ import ext::*;
1515

1616
export expand_syntax_ext;
1717

18-
// FIXME: Need to thread parser through here to handle errors correctly
18+
1919
fn expand_syntax_ext(&ext_ctxt cx,
2020
&parser::parser p,
2121
common::span sp,
@@ -29,20 +29,20 @@ fn expand_syntax_ext(&ext_ctxt cx,
2929
// FIXME: if this was more thorough it would manufacture an
3030
// option::t[str] rather than just an maybe-empty string.
3131

32-
auto var = expr_to_str(cx, p, args.(0));
32+
auto var = expr_to_str(cx, args.(0));
3333
alt (generic_os::getenv(var)) {
3434
case (option::none) {
35-
ret make_new_str(p, sp, "");
35+
ret make_new_str(cx, sp, "");
3636
}
3737
case (option::some(?s)) {
38-
ret make_new_str(p, sp, s);
38+
ret make_new_str(cx, sp, s);
3939
}
4040
}
4141
}
4242

4343
// FIXME: duplicate code copied from extfmt:
4444

45-
fn expr_to_str(&ext_ctxt cx, parser::parser p,
45+
fn expr_to_str(&ext_ctxt cx,
4646
@ast::expr expr) -> str {
4747
alt (expr.node) {
4848
case (ast::expr_lit(?l, _)) {
@@ -61,16 +61,16 @@ fn expr_to_str(&ext_ctxt cx, parser::parser p,
6161
}
6262
}
6363

64-
fn make_new_lit(parser::parser p, common::span sp, ast::lit_ lit)
64+
fn make_new_lit(&ext_ctxt cx, common::span sp, ast::lit_ lit)
6565
-> @ast::expr {
6666
auto sp_lit = @rec(node=lit, span=sp);
67-
auto expr = ast::expr_lit(sp_lit, p.get_ann());
67+
auto expr = ast::expr_lit(sp_lit, cx.next_ann());
6868
ret @rec(node=expr, span=sp);
6969
}
7070

71-
fn make_new_str(parser::parser p, common::span sp, str s) -> @ast::expr {
71+
fn make_new_str(&ext_ctxt cx, common::span sp, str s) -> @ast::expr {
7272
auto lit = ast::lit_str(s);
73-
ret make_new_lit(p, sp, lit);
73+
ret make_new_lit(cx, sp, lit);
7474
}
7575

7676
//

‎src/comp/front/extfmt.rs

Lines changed: 58 additions & 56 deletions
Original file line numberDiff line numberDiff line change
@@ -65,59 +65,60 @@ fn expr_to_str(&ext_ctxt cx, @ast::expr expr) -> str {
6565
fn pieces_to_expr(&ext_ctxt cx, parser p, common::span sp,
6666
vec[piece] pieces, vec[@ast::expr] args) -> @ast::expr {
6767

68-
fn make_new_lit(parser p, common::span sp, ast::lit_ lit) -> @ast::expr {
68+
fn make_new_lit(&ext_ctxt cx,
69+
common::span sp, ast::lit_ lit) -> @ast::expr {
6970
auto sp_lit = @rec(node=lit, span=sp);
70-
auto expr = ast::expr_lit(sp_lit, p.get_ann());
71+
auto expr = ast::expr_lit(sp_lit, cx.next_ann());
7172
ret @rec(node=expr, span=sp);
7273
}
7374

74-
fn make_new_str(parser p, common::span sp, str s) -> @ast::expr {
75+
fn make_new_str(&ext_ctxt cx, common::span sp, str s) -> @ast::expr {
7576
auto lit = ast::lit_str(s);
76-
ret make_new_lit(p, sp, lit);
77+
ret make_new_lit(cx, sp, lit);
7778
}
7879

79-
fn make_new_int(parser p, common::span sp, int i) -> @ast::expr {
80+
fn make_new_int(&ext_ctxt cx, common::span sp, int i) -> @ast::expr {
8081
auto lit = ast::lit_int(i);
81-
ret make_new_lit(p, sp, lit);
82+
ret make_new_lit(cx, sp, lit);
8283
}
8384

84-
fn make_new_uint(parser p, common::span sp, uint u) -> @ast::expr {
85+
fn make_new_uint(&ext_ctxt cx, common::span sp, uint u) -> @ast::expr {
8586
auto lit = ast::lit_uint(u);
86-
ret make_new_lit(p, sp, lit);
87+
ret make_new_lit(cx, sp, lit);
8788
}
8889

89-
fn make_add_expr(parser p, common::span sp,
90+
fn make_add_expr(&ext_ctxt cx, common::span sp,
9091
@ast::expr lhs, @ast::expr rhs) -> @ast::expr {
91-
auto binexpr = ast::expr_binary(ast::add, lhs, rhs, p.get_ann());
92+
auto binexpr = ast::expr_binary(ast::add, lhs, rhs, cx.next_ann());
9293
ret @rec(node=binexpr, span=sp);
9394
}
9495

95-
fn make_path_expr(parser p, common::span sp, vec[ast::ident] idents)
96+
fn make_path_expr(&ext_ctxt cx, common::span sp, vec[ast::ident] idents)
9697
-> @ast::expr {
9798
let vec[@ast::ty] types = [];
9899
auto path = rec(idents=idents, types=types);
99100
auto sp_path = rec(node=path, span=sp);
100-
auto pathexpr = ast::expr_path(sp_path, p.get_ann());
101+
auto pathexpr = ast::expr_path(sp_path, cx.next_ann());
101102
auto sp_pathexpr = @rec(node=pathexpr, span=sp);
102103
ret sp_pathexpr;
103104
}
104105

105-
fn make_vec_expr(parser p, common::span sp, vec[@ast::expr] exprs)
106+
fn make_vec_expr(&ext_ctxt cx, common::span sp, vec[@ast::expr] exprs)
106107
-> @ast::expr {
107-
auto vecexpr = ast::expr_vec(exprs, ast::imm, p.get_ann());
108+
auto vecexpr = ast::expr_vec(exprs, ast::imm, cx.next_ann());
108109
auto sp_vecexpr = @rec(node=vecexpr, span=sp);
109110
ret sp_vecexpr;
110111
}
111112

112-
fn make_call(parser p, common::span sp, vec[ast::ident] fn_path,
113+
fn make_call(&ext_ctxt cx, common::span sp, vec[ast::ident] fn_path,
113114
vec[@ast::expr] args) -> @ast::expr {
114-
auto pathexpr = make_path_expr(p, sp, fn_path);
115-
auto callexpr = ast::expr_call(pathexpr, args, p.get_ann());
115+
auto pathexpr = make_path_expr(cx, sp, fn_path);
116+
auto callexpr = ast::expr_call(pathexpr, args, cx.next_ann());
116117
auto sp_callexpr = @rec(node=callexpr, span=sp);
117118
ret sp_callexpr;
118119
}
119120

120-
fn make_rec_expr(parser p, common::span sp,
121+
fn make_rec_expr(&ext_ctxt cx, common::span sp,
121122
vec[tup(ast::ident, @ast::expr)] fields) -> @ast::expr {
122123
let vec[ast::field] astfields = [];
123124
for (tup(ast::ident, @ast::expr) field in fields) {
@@ -131,7 +132,7 @@ fn pieces_to_expr(&ext_ctxt cx, parser p, common::span sp,
131132

132133
auto recexpr = ast::expr_rec(astfields,
133134
option::none[@ast::expr],
134-
p.get_ann());
135+
cx.next_ann());
135136
auto sp_recexpr = @rec(node=recexpr, span=sp);
136137
ret sp_recexpr;
137138
}
@@ -142,17 +143,18 @@ fn pieces_to_expr(&ext_ctxt cx, parser p, common::span sp,
142143
ret ["std", "extfmt", "rt", ident];
143144
}
144145

145-
fn make_rt_path_expr(parser p, common::span sp, str ident) -> @ast::expr {
146+
fn make_rt_path_expr(&ext_ctxt cx,
147+
common::span sp, str ident) -> @ast::expr {
146148
auto path = make_path_vec(ident);
147-
ret make_path_expr(p, sp, path);
149+
ret make_path_expr(cx, sp, path);
148150
}
149151

150152
// Produces an AST expression that represents a RT::conv record,
151153
// which tells the RT::conv* functions how to perform the conversion
152154
fn make_rt_conv_expr(&ext_ctxt cx,
153-
parser p, common::span sp, &conv cnv) -> @ast::expr {
155+
common::span sp, &conv cnv) -> @ast::expr {
154156

155-
fn make_flags(parser p, common::span sp, vec[flag] flags)
157+
fn make_flags(&ext_ctxt cx, common::span sp, vec[flag] flags)
156158
-> @ast::expr {
157159
let vec[@ast::expr] flagexprs = [];
158160
for (flag f in flags) {
@@ -174,38 +176,38 @@ fn pieces_to_expr(&ext_ctxt cx, parser p, common::span sp,
174176
fstr = "flag_alternate";
175177
}
176178
}
177-
flagexprs += [make_rt_path_expr(p, sp, fstr)];
179+
flagexprs += [make_rt_path_expr(cx, sp, fstr)];
178180
}
179181

180182
// FIXME: 0-length vectors can't have their type inferred
181183
// through the rec that these flags are a member of, so
182184
// this is a hack placeholder flag
183185
if (vec::len[@ast::expr](flagexprs) == 0u) {
184-
flagexprs += [make_rt_path_expr(p, sp, "flag_none")];
186+
flagexprs += [make_rt_path_expr(cx, sp, "flag_none")];
185187
}
186188

187-
ret make_vec_expr(p, sp, flagexprs);
189+
ret make_vec_expr(cx, sp, flagexprs);
188190
}
189191

190192
fn make_count(&ext_ctxt cx,
191-
parser p, common::span sp, &count cnt) -> @ast::expr {
193+
common::span sp, &count cnt) -> @ast::expr {
192194
alt (cnt) {
193195
case (count_implied) {
194-
ret make_rt_path_expr(p, sp, "count_implied");
196+
ret make_rt_path_expr(cx, sp, "count_implied");
195197
}
196198
case (count_is(?c)) {
197-
auto count_lit = make_new_int(p, sp, c);
199+
auto count_lit = make_new_int(cx, sp, c);
198200
auto count_is_path = make_path_vec("count_is");
199201
auto count_is_args = [count_lit];
200-
ret make_call(p, sp, count_is_path, count_is_args);
202+
ret make_call(cx, sp, count_is_path, count_is_args);
201203
}
202204
case (_) {
203205
cx.span_unimpl(sp, "unimplemented #fmt conversion");
204206
}
205207
}
206208
}
207209

208-
fn make_ty(parser p, common::span sp, &ty t) -> @ast::expr {
210+
fn make_ty(&ext_ctxt cx, common::span sp, &ty t) -> @ast::expr {
209211
auto rt_type;
210212
alt (t) {
211213
case (ty_hex(?c)) {
@@ -229,43 +231,43 @@ fn pieces_to_expr(&ext_ctxt cx, parser p, common::span sp,
229231
}
230232
}
231233

232-
ret make_rt_path_expr(p, sp, rt_type);
234+
ret make_rt_path_expr(cx, sp, rt_type);
233235
}
234236

235-
fn make_conv_rec(parser p,
237+
fn make_conv_rec(&ext_ctxt cx,
236238
common::span sp,
237239
@ast::expr flags_expr,
238240
@ast::expr width_expr,
239241
@ast::expr precision_expr,
240242
@ast::expr ty_expr) -> @ast::expr {
241-
ret make_rec_expr(p, sp, [tup("flags", flags_expr),
243+
ret make_rec_expr(cx, sp, [tup("flags", flags_expr),
242244
tup("width", width_expr),
243245
tup("precision", precision_expr),
244246
tup("ty", ty_expr)]);
245247
}
246248

247-
auto rt_conv_flags = make_flags(p, sp, cnv.flags);
248-
auto rt_conv_width = make_count(cx, p, sp, cnv.width);
249-
auto rt_conv_precision = make_count(cx, p, sp, cnv.precision);
250-
auto rt_conv_ty = make_ty(p, sp, cnv.ty);
251-
ret make_conv_rec(p,
249+
auto rt_conv_flags = make_flags(cx, sp, cnv.flags);
250+
auto rt_conv_width = make_count(cx, sp, cnv.width);
251+
auto rt_conv_precision = make_count(cx, sp, cnv.precision);
252+
auto rt_conv_ty = make_ty(cx, sp, cnv.ty);
253+
ret make_conv_rec(cx,
252254
sp,
253255
rt_conv_flags,
254256
rt_conv_width,
255257
rt_conv_precision,
256258
rt_conv_ty);
257259
}
258260

259-
fn make_conv_call(&ext_ctxt cx, parser p, common::span sp, str conv_type,
261+
fn make_conv_call(&ext_ctxt cx, common::span sp, str conv_type,
260262
&conv cnv, @ast::expr arg) -> @ast::expr {
261263
auto fname = "conv_" + conv_type;
262264
auto path = make_path_vec(fname);
263-
auto cnv_expr = make_rt_conv_expr(cx, p, sp, cnv);
265+
auto cnv_expr = make_rt_conv_expr(cx, sp, cnv);
264266
auto args = [cnv_expr, arg];
265-
ret make_call(p, arg.span, path, args);
267+
ret make_call(cx, arg.span, path, args);
266268
}
267269

268-
fn make_new_conv(&ext_ctxt cx, parser p, common::span sp,
270+
fn make_new_conv(&ext_ctxt cx, common::span sp,
269271
conv cnv, @ast::expr arg) -> @ast::expr {
270272

271273
// FIXME: Extract all this validation into extfmt::ct
@@ -343,32 +345,32 @@ fn pieces_to_expr(&ext_ctxt cx, parser p, common::span sp,
343345

344346
alt (cnv.ty) {
345347
case (ty_str) {
346-
ret make_conv_call(cx, p, arg.span, "str", cnv, arg);
348+
ret make_conv_call(cx, arg.span, "str", cnv, arg);
347349
}
348350
case (ty_int(?sign)) {
349351
alt (sign) {
350352
case (signed) {
351-
ret make_conv_call(cx, p, arg.span, "int", cnv, arg);
353+
ret make_conv_call(cx, arg.span, "int", cnv, arg);
352354
}
353355
case (unsigned) {
354-
ret make_conv_call(cx, p, arg.span, "uint", cnv, arg);
356+
ret make_conv_call(cx, arg.span, "uint", cnv, arg);
355357
}
356358
}
357359
}
358360
case (ty_bool) {
359-
ret make_conv_call(cx, p, arg.span, "bool", cnv, arg);
361+
ret make_conv_call(cx, arg.span, "bool", cnv, arg);
360362
}
361363
case (ty_char) {
362-
ret make_conv_call(cx, p, arg.span, "char", cnv, arg);
364+
ret make_conv_call(cx, arg.span, "char", cnv, arg);
363365
}
364366
case (ty_hex(_)) {
365-
ret make_conv_call(cx, p, arg.span, "uint", cnv, arg);
367+
ret make_conv_call(cx, arg.span, "uint", cnv, arg);
366368
}
367369
case (ty_bits) {
368-
ret make_conv_call(cx, p, arg.span, "uint", cnv, arg);
370+
ret make_conv_call(cx, arg.span, "uint", cnv, arg);
369371
}
370372
case (ty_octal) {
371-
ret make_conv_call(cx, p, arg.span, "uint", cnv, arg);
373+
ret make_conv_call(cx, arg.span, "uint", cnv, arg);
372374
}
373375
case (_) {
374376
cx.span_unimpl(sp, unsupported);
@@ -470,14 +472,14 @@ fn pieces_to_expr(&ext_ctxt cx, parser p, common::span sp,
470472

471473
auto fmt_sp = args.(0).span;
472474
auto n = 0u;
473-
auto tmp_expr = make_new_str(p, sp, "");
475+
auto tmp_expr = make_new_str(cx, sp, "");
474476
auto nargs = vec::len[@ast::expr](args);
475477

476478
for (piece pc in pieces) {
477479
alt (pc) {
478480
case (piece_string(?s)) {
479-
auto s_expr = make_new_str(p, fmt_sp, s);
480-
tmp_expr = make_add_expr(p, fmt_sp, tmp_expr, s_expr);
481+
auto s_expr = make_new_str(cx, fmt_sp, s);
482+
tmp_expr = make_add_expr(cx, fmt_sp, tmp_expr, s_expr);
481483
}
482484
case (piece_conv(?conv)) {
483485
n += 1u;
@@ -492,8 +494,8 @@ fn pieces_to_expr(&ext_ctxt cx, parser p, common::span sp,
492494
//log_conv(conv);
493495

494496
auto arg_expr = args.(n);
495-
auto c_expr = make_new_conv(cx, p, fmt_sp, conv, arg_expr);
496-
tmp_expr = make_add_expr(p, fmt_sp, tmp_expr, c_expr);
497+
auto c_expr = make_new_conv(cx, fmt_sp, conv, arg_expr);
498+
tmp_expr = make_add_expr(cx, fmt_sp, tmp_expr, c_expr);
497499
}
498500
}
499501
}

0 commit comments

Comments
 (0)