Skip to content

Commit 7e1b671

Browse files
CentrilCentril
committed
Cleanup using the new parse_*_seq methods.
1 parent 7aeb4b7 commit 7e1b671

File tree

1 file changed

+60
-96
lines changed

1 file changed

+60
-96
lines changed

‎src/libsyntax/parse/parser.rs

Lines changed: 60 additions & 96 deletions
Original file line numberDiff line numberDiff line change
@@ -1817,15 +1817,7 @@ impl<'a> Parser<'a> {
18171817
AngleBracketedArgs { args, constraints, span }.into()
18181818
} else {
18191819
// `(T, U) -> R`
1820-
self.bump(); // `(`
1821-
let (inputs, recovered) = self.parse_seq_to_before_tokens(
1822-
&[&token::CloseDelim(token::Paren)],
1823-
SeqSep::trailing_allowed(token::Comma),
1824-
TokenExpectType::Expect,
1825-
|p| p.parse_ty())?;
1826-
if !recovered {
1827-
self.bump(); // `)`
1828-
}
1820+
let (inputs, _) = self.parse_paren_comma_seq(|p| p.parse_ty())?;
18291821
let span = lo.to(self.prev_span);
18301822
let output = if self.eat(&token::RArrow) {
18311823
Some(self.parse_ty_common(false, false, false)?)
@@ -2529,12 +2521,7 @@ impl<'a> Parser<'a> {
25292521
Ok(match self.token.kind {
25302522
token::OpenDelim(token::Paren) => {
25312523
// Method call `expr.f()`
2532-
let mut args = self.parse_unspanned_seq(
2533-
&token::OpenDelim(token::Paren),
2534-
&token::CloseDelim(token::Paren),
2535-
SeqSep::trailing_allowed(token::Comma),
2536-
|p| Ok(p.parse_expr()?)
2537-
)?;
2524+
let mut args = self.parse_paren_expr_seq()?;
25382525
args.insert(0, self_arg);
25392526

25402527
let span = lo.to(self.prev_span);
@@ -2619,12 +2606,7 @@ impl<'a> Parser<'a> {
26192606
match self.token.kind {
26202607
// expr(...)
26212608
token::OpenDelim(token::Paren) => {
2622-
let seq = self.parse_unspanned_seq(
2623-
&token::OpenDelim(token::Paren),
2624-
&token::CloseDelim(token::Paren),
2625-
SeqSep::trailing_allowed(token::Comma),
2626-
|p| Ok(p.parse_expr()?)
2627-
).map(|es| {
2609+
let seq = self.parse_paren_expr_seq().map(|es| {
26282610
let nd = self.mk_call(e, es);
26292611
let hi = self.prev_span;
26302612
self.mk_expr(lo.to(hi), nd, ThinVec::new())
@@ -5376,59 +5358,48 @@ impl<'a> Parser<'a> {
53765358

53775359
fn parse_fn_args(&mut self, named_args: bool, allow_c_variadic: bool)
53785360
-> PResult<'a, (Vec<Arg> , bool)> {
5379-
self.expect(&token::OpenDelim(token::Paren))?;
5380-
53815361
let sp = self.token.span;
53825362
let mut c_variadic = false;
5383-
let (args, recovered): (Vec<Option<Arg>>, bool) =
5384-
self.parse_seq_to_before_end(
5385-
&token::CloseDelim(token::Paren),
5386-
SeqSep::trailing_allowed(token::Comma),
5387-
|p| {
5388-
let do_not_enforce_named_arguments_for_c_variadic =
5389-
|token: &token::Token| -> bool {
5390-
if token == &token::DotDotDot {
5391-
false
5392-
} else {
5393-
named_args
5394-
}
5395-
};
5396-
match p.parse_arg_general(
5397-
false,
5398-
allow_c_variadic,
5399-
do_not_enforce_named_arguments_for_c_variadic
5400-
) {
5401-
Ok(arg) => {
5402-
if let TyKind::CVarArgs = arg.ty.node {
5403-
c_variadic = true;
5404-
if p.token != token::CloseDelim(token::Paren) {
5405-
let span = p.token.span;
5406-
p.span_err(span,
5407-
"`...` must be the last argument of a C-variadic function");
5408-
Ok(None)
5409-
} else {
5410-
Ok(Some(arg))
5411-
}
5412-
} else {
5413-
Ok(Some(arg))
5414-
}
5415-
},
5416-
Err(mut e) => {
5417-
e.emit();
5418-
let lo = p.prev_span;
5419-
// Skip every token until next possible arg or end.
5420-
p.eat_to_tokens(&[&token::Comma, &token::CloseDelim(token::Paren)]);
5421-
// Create a placeholder argument for proper arg count (issue #34264).
5422-
let span = lo.to(p.prev_span);
5423-
Ok(Some(dummy_arg(Ident::new(kw::Invalid, span))))
5363+
let (args, _): (Vec<Option<Arg>>, _) = self.parse_paren_comma_seq(|p| {
5364+
let do_not_enforce_named_arguments_for_c_variadic =
5365+
|token: &token::Token| -> bool {
5366+
if token == &token::DotDotDot {
5367+
false
5368+
} else {
5369+
named_args
5370+
}
5371+
};
5372+
match p.parse_arg_general(
5373+
false,
5374+
allow_c_variadic,
5375+
do_not_enforce_named_arguments_for_c_variadic
5376+
) {
5377+
Ok(arg) => {
5378+
if let TyKind::CVarArgs = arg.ty.node {
5379+
c_variadic = true;
5380+
if p.token != token::CloseDelim(token::Paren) {
5381+
let span = p.token.span;
5382+
p.span_err(span,
5383+
"`...` must be the last argument of a C-variadic function");
5384+
Ok(None)
5385+
} else {
5386+
Ok(Some(arg))
54245387
}
5388+
} else {
5389+
Ok(Some(arg))
54255390
}
5391+
},
5392+
Err(mut e) => {
5393+
e.emit();
5394+
let lo = p.prev_span;
5395+
// Skip every token until next possible arg or end.
5396+
p.eat_to_tokens(&[&token::Comma, &token::CloseDelim(token::Paren)]);
5397+
// Create a placeholder argument for proper arg count (issue #34264).
5398+
let span = lo.to(p.prev_span);
5399+
Ok(Some(dummy_arg(Ident::new(kw::Invalid, span))))
54265400
}
5427-
)?;
5428-
5429-
if !recovered {
5430-
self.eat(&token::CloseDelim(token::Paren));
5431-
}
5401+
}
5402+
})?;
54325403

54335404
let args: Vec<_> = args.into_iter().filter_map(|x| x).collect();
54345405

@@ -5590,7 +5561,7 @@ impl<'a> Parser<'a> {
55905561
(vec![self_arg], false)
55915562
} else if self.eat(&token::Comma) {
55925563
let mut fn_inputs = vec![self_arg];
5593-
let (mut input, recovered) = self.parse_seq_to_before_end(
5564+
let (mut input, _, recovered) = self.parse_seq_to_before_end(
55945565
&token::CloseDelim(token::Paren), sep, parse_arg_fn)?;
55955566
fn_inputs.append(&mut input);
55965567
(fn_inputs, recovered)
@@ -5601,7 +5572,9 @@ impl<'a> Parser<'a> {
56015572
}
56025573
}
56035574
} else {
5604-
self.parse_seq_to_before_end(&token::CloseDelim(token::Paren), sep, parse_arg_fn)?
5575+
let (input, _, recovered) =
5576+
self.parse_seq_to_before_end(&token::CloseDelim(token::Paren), sep, parse_arg_fn)?;
5577+
(input, recovered)
56055578
};
56065579

56075580
if !recovered {
@@ -6202,26 +6175,20 @@ impl<'a> Parser<'a> {
62026175
fn parse_tuple_struct_body(&mut self) -> PResult<'a, Vec<StructField>> {
62036176
// This is the case where we find `struct Foo<T>(T) where T: Copy;`
62046177
// Unit like structs are handled in parse_item_struct function
6205-
let fields = self.parse_unspanned_seq(
6206-
&token::OpenDelim(token::Paren),
6207-
&token::CloseDelim(token::Paren),
6208-
SeqSep::trailing_allowed(token::Comma),
6209-
|p| {
6210-
let attrs = p.parse_outer_attributes()?;
6211-
let lo = p.token.span;
6212-
let vis = p.parse_visibility(true)?;
6213-
let ty = p.parse_ty()?;
6214-
Ok(StructField {
6215-
span: lo.to(ty.span),
6216-
vis,
6217-
ident: None,
6218-
id: ast::DUMMY_NODE_ID,
6219-
ty,
6220-
attrs,
6221-
})
6222-
})?;
6223-
6224-
Ok(fields)
6178+
self.parse_paren_comma_seq(|p| {
6179+
let attrs = p.parse_outer_attributes()?;
6180+
let lo = p.token.span;
6181+
let vis = p.parse_visibility(true)?;
6182+
let ty = p.parse_ty()?;
6183+
Ok(StructField {
6184+
span: lo.to(ty.span),
6185+
vis,
6186+
ident: None,
6187+
id: ast::DUMMY_NODE_ID,
6188+
ty,
6189+
attrs,
6190+
})
6191+
}).map(|(r, _)| r)
62256192
}
62266193

62276194
/// Parses a structure field declaration.
@@ -7803,11 +7770,8 @@ impl<'a> Parser<'a> {
78037770
/// USE_TREE_LIST = Ø | (USE_TREE `,`)* USE_TREE [`,`]
78047771
/// ```
78057772
fn parse_use_tree_list(&mut self) -> PResult<'a, Vec<(UseTree, ast::NodeId)>> {
7806-
self.parse_unspanned_seq(&token::OpenDelim(token::Brace),
7807-
&token::CloseDelim(token::Brace),
7808-
SeqSep::trailing_allowed(token::Comma), |this| {
7809-
Ok((this.parse_use_tree()?, ast::DUMMY_NODE_ID))
7810-
})
7773+
self.parse_delim_comma_seq(token::Brace, |p| Ok((p.parse_use_tree()?, ast::DUMMY_NODE_ID)))
7774+
.map(|(r, _)| r)
78117775
}
78127776

78137777
fn parse_rename(&mut self) -> PResult<'a, Option<Ident>> {

0 commit comments

Comments
 (0)