Skip to content

Commit fd85239

Browse files
pcwaltonpcwalton
committed
syntax: Remove several deep copies that were happening due to misuse of parse_seq
1 parent 26faa37 commit fd85239

File tree

2 files changed

+90
-76
lines changed

2 files changed

+90
-76
lines changed

‎src/libsyntax/parse/common.rs

Lines changed: 10 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -209,9 +209,16 @@ impl parser_common for parser {
209209
ret v;
210210
}
211211

212-
// FIXME: A lot of callers go through here, only to copy out the T and
213-
// discard the spanned<> wrapper. I feel as though there should be a
214-
// version of this that does not return a spanned result.
212+
fn parse_unspanned_seq<T: copy>(bra: token::token, ket: token::token,
213+
sep: seq_sep, f: fn(parser) -> T) -> [T] {
214+
self.expect(bra);
215+
let result = self.parse_seq_to_before_end::<T>(ket, sep, f);
216+
self.bump();
217+
ret result;
218+
}
219+
220+
// NB: Do not use this function unless you actually plan to place the
221+
// spanned list in the AST.
215222
fn parse_seq<T: copy>(bra: token::token, ket: token::token, sep: seq_sep,
216223
f: fn(parser) -> T) -> spanned<[T]> {
217224
let lo = self.span.lo;

‎src/libsyntax/parse/parser.rs

Lines changed: 80 additions & 73 deletions
Original file line numberDiff line numberDiff line change
@@ -150,8 +150,8 @@ class parser {
150150

151151
fn parse_ty_fn_decl(purity: ast::purity) -> fn_decl {
152152
let inputs =
153-
self.parse_seq(token::LPAREN, token::RPAREN,
154-
seq_sep(token::COMMA)) { |p|
153+
self.parse_unspanned_seq(token::LPAREN, token::RPAREN,
154+
seq_sep(token::COMMA)) { |p|
155155
let mode = p.parse_arg_mode();
156156
let name = if is_plain_ident(p.token)
157157
&& p.look_ahead(1u) == token::COLON {
@@ -170,13 +170,14 @@ class parser {
170170
// story on constrained types.
171171
let constrs: [@constr] = [];
172172
let (ret_style, ret_ty) = self.parse_ret_ty();
173-
ret {inputs: inputs.node, output: ret_ty,
173+
ret {inputs: inputs, output: ret_ty,
174174
purity: purity, cf: ret_style,
175175
constraints: constrs};
176176
}
177177

178178
fn parse_ty_methods() -> [ty_method] {
179-
(self.parse_seq(token::LBRACE, token::RBRACE, seq_sep_none()) { |p|
179+
self.parse_unspanned_seq(token::LBRACE, token::RBRACE,
180+
seq_sep_none()) { |p|
180181
let attrs = p.parse_outer_attributes();
181182
let flo = p.span.lo;
182183
let pur = p.parse_fn_purity();
@@ -186,7 +187,7 @@ class parser {
186187
self.expect(token::SEMI);
187188
{ident: ident, attrs: attrs, decl: {purity: pur with d}, tps: tps,
188189
span: mk_sp(flo, fhi)}
189-
}).node
190+
}
190191
}
191192

192193
fn parse_mt() -> mt {
@@ -241,21 +242,21 @@ class parser {
241242
fn parse_ty_constr(fn_args: [arg]) -> @constr {
242243
let lo = self.span.lo;
243244
let path = self.parse_path_without_tps();
244-
let args: {node: [@constr_arg], span: span} =
245-
self.parse_seq(token::LPAREN, token::RPAREN,
246-
seq_sep(token::COMMA),
247-
{|p| p.parse_constr_arg(fn_args)});
248-
ret @spanned(lo, args.span.hi,
249-
{path: path, args: args.node, id: self.get_id()});
245+
let args =
246+
self.parse_unspanned_seq(token::LPAREN, token::RPAREN,
247+
seq_sep(token::COMMA),
248+
{|p| p.parse_constr_arg(fn_args)});
249+
ret @spanned(lo, self.span.hi,
250+
{path: path, args: args, id: self.get_id()});
250251
}
251252

252253
fn parse_constr_in_type() -> @ty_constr {
253254
let lo = self.span.lo;
254255
let path = self.parse_path_without_tps();
255256
let args: [@ty_constr_arg] =
256-
self.parse_seq(token::LPAREN, token::RPAREN,
257-
seq_sep(token::COMMA),
258-
{|p| p.parse_type_constr_arg()}).node;
257+
self.parse_unspanned_seq(token::LPAREN, token::RPAREN,
258+
seq_sep(token::COMMA),
259+
{|p| p.parse_type_constr_arg()});
259260
let hi = self.span.lo;
260261
let tc: ty_constr_ = {path: path, args: args, id: self.get_id()};
261262
ret @spanned(lo, hi, tc);
@@ -370,15 +371,15 @@ class parser {
370371
self.bump();
371372
ty_ptr(self.parse_mt())
372373
} else if self.token == token::LBRACE {
373-
let elems = self.parse_seq(token::LBRACE, token::RBRACE,
374-
seq_sep_opt(token::COMMA),
375-
{|p| p.parse_ty_field()});
376-
if vec::len(elems.node) == 0u {
374+
let elems = self.parse_unspanned_seq(token::LBRACE, token::RBRACE,
375+
seq_sep_opt(token::COMMA),
376+
{|p| p.parse_ty_field()});
377+
if vec::len(elems) == 0u {
377378
self.unexpected_last(token::RBRACE);
378379
}
379-
let hi = elems.span.hi;
380+
let hi = self.span.hi;
380381

381-
let t = ty_rec(elems.node);
382+
let t = ty_rec(elems);
382383
if self.token == token::COLON {
383384
self.bump();
384385
ty_constr(@{id: self.get_id(),
@@ -813,11 +814,11 @@ class parser {
813814
ex = ex_ext.node;
814815
} else if self.eat_keyword("bind") {
815816
let e = self.parse_expr_res(RESTRICT_NO_CALL_EXPRS);
816-
let es = self.parse_seq(token::LPAREN, token::RPAREN,
817-
seq_sep(token::COMMA),
818-
{|p| p.parse_expr_or_hole()});
819-
hi = es.span.hi;
820-
ex = expr_bind(e, es.node);
817+
let es = self.parse_unspanned_seq(token::LPAREN, token::RPAREN,
818+
seq_sep(token::COMMA),
819+
{|p| p.parse_expr_or_hole()});
820+
hi = self.span.hi;
821+
ex = expr_bind(e, es);
821822
} else if self.eat_keyword("fail") {
822823
if can_begin_expr(self.token) {
823824
let e = self.parse_expr();
@@ -920,37 +921,37 @@ class parser {
920921
let sep = seq_sep(token::COMMA);
921922
let mut e = none;
922923
if (self.token == token::LPAREN || self.token == token::LBRACKET) {
924+
let lo = self.span.lo;
923925
let es =
924926
if self.token == token::LPAREN {
925-
self.parse_seq(token::LPAREN, token::RPAREN,
926-
sep, {|p| p.parse_expr()})
927-
} else {
928-
self.parse_seq(token::LBRACKET, token::RBRACKET,
929-
sep, {|p| p.parse_expr()})
930-
};
931-
let hi = es.span.hi;
932-
e = some(self.mk_expr(es.span.lo, hi,
933-
expr_vec(es.node, m_imm)));
934-
}
935-
let mut b = none;
936-
if self.token == token::LBRACE {
937-
self.bump();
938-
let lo = self.span.lo;
939-
let mut depth = 1u;
940-
while (depth > 0u) {
941-
alt (self.token) {
942-
token::LBRACE {depth += 1u;}
943-
token::RBRACE {depth -= 1u;}
944-
token::EOF {self.fatal("unexpected EOF in macro body");}
945-
_ {}
946-
}
927+
self.parse_unspanned_seq(token::LPAREN, token::RPAREN,
928+
sep, {|p| p.parse_expr()})
929+
} else {
930+
self.parse_unspanned_seq(token::LBRACKET, token::RBRACKET,
931+
sep, {|p| p.parse_expr()})
932+
};
933+
let hi = self.span.hi;
934+
e = some(self.mk_expr(lo, hi, expr_vec(es, m_imm)));
935+
}
936+
let mut b = none;
937+
if self.token == token::LBRACE {
947938
self.bump();
939+
let lo = self.span.lo;
940+
let mut depth = 1u;
941+
while (depth > 0u) {
942+
alt (self.token) {
943+
token::LBRACE {depth += 1u;}
944+
token::RBRACE {depth -= 1u;}
945+
token::EOF {self.fatal("unexpected EOF in macro body");}
946+
_ {}
947+
}
948+
self.bump();
949+
}
950+
let hi = self.last_span.lo;
951+
b = some({span: mk_sp(lo,hi)});
948952
}
949-
let hi = self.last_span.lo;
950-
b = some({span: mk_sp(lo,hi)});
953+
ret self.mk_mac_expr(lo, self.span.hi, mac_invoc(pth, e, b));
951954
}
952-
ret self.mk_mac_expr(lo, self.span.hi, mac_invoc(pth, e, b));
953-
}
954955

955956
fn parse_dot_or_call_expr() -> pexpr {
956957
let b = self.parse_bottom_expr();
@@ -989,16 +990,17 @@ class parser {
989990
alt copy self.token {
990991
// expr(...)
991992
token::LPAREN if self.permits_call() {
992-
let es_opt = self.parse_seq(token::LPAREN, token::RPAREN,
993-
seq_sep(token::COMMA),
994-
{|p| p.parse_expr_or_hole()});
995-
hi = es_opt.span.hi;
993+
let es_opt =
994+
self.parse_unspanned_seq(token::LPAREN, token::RPAREN,
995+
seq_sep(token::COMMA),
996+
{|p| p.parse_expr_or_hole()});
997+
hi = self.span.hi;
996998

997999
let nd =
998-
if vec::any(es_opt.node, {|e| option::is_none(e) }) {
999-
expr_bind(self.to_expr(e), es_opt.node)
1000+
if vec::any(es_opt, {|e| option::is_none(e) }) {
1001+
expr_bind(self.to_expr(e), es_opt)
10001002
} else {
1001-
let es = vec::map(es_opt.node) {|e| option::get(e) };
1003+
let es = vec::map(es_opt) {|e| option::get(e) };
10021004
expr_call(self.to_expr(e), es, false)
10031005
};
10041006
e = self.mk_pexpr(lo, hi, nd);
@@ -1458,11 +1460,12 @@ class parser {
14581460
self.expect(token::RPAREN);
14591461
}
14601462
_ {
1461-
let a = self.parse_seq(token::LPAREN, token::RPAREN,
1462-
seq_sep(token::COMMA),
1463-
{|p| p.parse_pat()});
1464-
args = a.node;
1465-
hi = a.span.hi;
1463+
args =
1464+
self.parse_unspanned_seq(token::LPAREN,
1465+
token::RPAREN,
1466+
seq_sep(token::COMMA),
1467+
{|p| p.parse_pat()});
1468+
hi = self.span.hi;
14661469
}
14671470
}
14681471
}
@@ -1761,8 +1764,8 @@ class parser {
17611764
-> (fn_decl, capture_clause) {
17621765

17631766
let args_or_capture_items: [arg_or_capture_item] =
1764-
self.parse_seq(token::LPAREN, token::RPAREN,
1765-
seq_sep(token::COMMA), parse_arg_fn).node;
1767+
self.parse_unspanned_seq(token::LPAREN, token::RPAREN,
1768+
seq_sep(token::COMMA), parse_arg_fn);
17661769

17671770
let inputs = either::lefts(args_or_capture_items);
17681771
let capture_clause = @either::rights(args_or_capture_items);
@@ -1788,9 +1791,10 @@ class parser {
17881791
if self.eat(token::OROR) {
17891792
[]
17901793
} else {
1791-
self.parse_seq(token::BINOP(token::OR),
1792-
token::BINOP(token::OR), seq_sep(token::COMMA),
1793-
{|p| p.parse_fn_block_arg()}).node
1794+
self.parse_unspanned_seq(token::BINOP(token::OR),
1795+
token::BINOP(token::OR),
1796+
seq_sep(token::COMMA),
1797+
{|p| p.parse_fn_block_arg()})
17941798
}
17951799
};
17961800
let output = if self.eat(token::RARROW) {
@@ -2242,10 +2246,12 @@ class parser {
22422246
let mut args = [], disr_expr = none;
22432247
if self.token == token::LPAREN {
22442248
all_nullary = false;
2245-
let arg_tys = self.parse_seq(token::LPAREN, token::RPAREN,
2249+
let arg_tys =
2250+
self.parse_unspanned_seq(token::LPAREN,
2251+
token::RPAREN,
22462252
seq_sep(token::COMMA),
22472253
{|p| p.parse_ty(false)});
2248-
for arg_tys.node.each {|ty|
2254+
for arg_tys.each {|ty|
22492255
args += [{ty: ty, id: self.get_id()}];
22502256
}
22512257
} else if self.eat(token::EQ) {
@@ -2385,9 +2391,10 @@ class parser {
23852391
// foo::bar::{a,b,c}
23862392
token::LBRACE {
23872393
let idents =
2388-
self.parse_seq(token::LBRACE, token::RBRACE,
2389-
seq_sep(token::COMMA),
2390-
{|p| p.parse_path_list_ident()}).node;
2394+
self.parse_unspanned_seq(token::LBRACE, token::RBRACE,
2395+
seq_sep(token::COMMA),
2396+
{|p|
2397+
p.parse_path_list_ident()});
23912398
let path = @{span: mk_sp(lo, self.span.hi),
23922399
global: false, idents: path,
23932400
rp: none, types: []};

0 commit comments

Comments
 (0)