Skip to content

Commit 77d8752

Browse files
CentrilCentril
committed
Cleanup using the new parse_*_seq methods.
1 parent de3ae62 commit 77d8752

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
@@ -1812,15 +1812,7 @@ impl<'a> Parser<'a> {
18121812
AngleBracketedArgs { args, constraints, span }.into()
18131813
} else {
18141814
// `(T, U) -> R`
1815-
self.bump(); // `(`
1816-
let (inputs, recovered) = self.parse_seq_to_before_tokens(
1817-
&[&token::CloseDelim(token::Paren)],
1818-
SeqSep::trailing_allowed(token::Comma),
1819-
TokenExpectType::Expect,
1820-
|p| p.parse_ty())?;
1821-
if !recovered {
1822-
self.bump(); // `)`
1823-
}
1815+
let (inputs, _) = self.parse_paren_comma_seq(|p| p.parse_ty())?;
18241816
let span = lo.to(self.prev_span);
18251817
let output = if self.eat(&token::RArrow) {
18261818
Some(self.parse_ty_common(false, false, false)?)
@@ -2524,12 +2516,7 @@ impl<'a> Parser<'a> {
25242516
Ok(match self.token.kind {
25252517
token::OpenDelim(token::Paren) => {
25262518
// Method call `expr.f()`
2527-
let mut args = self.parse_unspanned_seq(
2528-
&token::OpenDelim(token::Paren),
2529-
&token::CloseDelim(token::Paren),
2530-
SeqSep::trailing_allowed(token::Comma),
2531-
|p| Ok(p.parse_expr()?)
2532-
)?;
2519+
let mut args = self.parse_paren_expr_seq()?;
25332520
args.insert(0, self_arg);
25342521

25352522
let span = lo.to(self.prev_span);
@@ -2614,12 +2601,7 @@ impl<'a> Parser<'a> {
26142601
match self.token.kind {
26152602
// expr(...)
26162603
token::OpenDelim(token::Paren) => {
2617-
let seq = self.parse_unspanned_seq(
2618-
&token::OpenDelim(token::Paren),
2619-
&token::CloseDelim(token::Paren),
2620-
SeqSep::trailing_allowed(token::Comma),
2621-
|p| Ok(p.parse_expr()?)
2622-
).map(|es| {
2604+
let seq = self.parse_paren_expr_seq().map(|es| {
26232605
let nd = self.mk_call(e, es);
26242606
let hi = self.prev_span;
26252607
self.mk_expr(lo.to(hi), nd, ThinVec::new())
@@ -5375,59 +5357,48 @@ impl<'a> Parser<'a> {
53755357

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

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

@@ -5589,7 +5560,7 @@ impl<'a> Parser<'a> {
55895560
(vec![self_arg], false)
55905561
} else if self.eat(&token::Comma) {
55915562
let mut fn_inputs = vec![self_arg];
5592-
let (mut input, recovered) = self.parse_seq_to_before_end(
5563+
let (mut input, _, recovered) = self.parse_seq_to_before_end(
55935564
&token::CloseDelim(token::Paren), sep, parse_arg_fn)?;
55945565
fn_inputs.append(&mut input);
55955566
(fn_inputs, recovered)
@@ -5600,7 +5571,9 @@ impl<'a> Parser<'a> {
56005571
}
56015572
}
56025573
} else {
5603-
self.parse_seq_to_before_end(&token::CloseDelim(token::Paren), sep, parse_arg_fn)?
5574+
let (input, _, recovered) =
5575+
self.parse_seq_to_before_end(&token::CloseDelim(token::Paren), sep, parse_arg_fn)?;
5576+
(input, recovered)
56045577
};
56055578

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

62266193
/// Parses a structure field declaration.
@@ -7789,11 +7756,8 @@ impl<'a> Parser<'a> {
77897756
/// USE_TREE_LIST = Ø | (USE_TREE `,`)* USE_TREE [`,`]
77907757
/// ```
77917758
fn parse_use_tree_list(&mut self) -> PResult<'a, Vec<(UseTree, ast::NodeId)>> {
7792-
self.parse_unspanned_seq(&token::OpenDelim(token::Brace),
7793-
&token::CloseDelim(token::Brace),
7794-
SeqSep::trailing_allowed(token::Comma), |this| {
7795-
Ok((this.parse_use_tree()?, ast::DUMMY_NODE_ID))
7796-
})
7759+
self.parse_delim_comma_seq(token::Brace, |p| Ok((p.parse_use_tree()?, ast::DUMMY_NODE_ID)))
7760+
.map(|(r, _)| r)
77977761
}
77987762

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

0 commit comments

Comments
 (0)