Skip to content

Commit a025ea2

Browse files
progvalprogval
committed
Use better names for spacing-related helpers.
1 parent 1d7ea49 commit a025ea2

File tree

6 files changed

+130
-129
lines changed

6 files changed

+130
-129
lines changed

‎src/expressions.rs

Lines changed: 35 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -31,9 +31,9 @@ named!(pub test<StrSpan, Box<Expression>>,
3131
| do_parse!(
3232
left: call!(Self::or_test) >>
3333
right: opt!(do_parse!(
34-
ws3!(keyword!("if")) >>
34+
ws_auto!(keyword!("if")) >>
3535
cond: call!(Self::or_test) >>
36-
ws3!(keyword!("else")) >>
36+
ws_auto!(keyword!("else")) >>
3737
right: call!(Self::test) >> (
3838
(cond, right)
3939
)
@@ -57,7 +57,7 @@ named!(test_nocond<StrSpan, Box<Expression>>,
5757

5858
// lambdef: 'lambda' [varargslist] ':' test
5959
named!(lambdef<StrSpan, Box<Expression>>,
60-
ws3!(do_parse!(
60+
ws_auto!(do_parse!(
6161
keyword!("lambda") >>
6262
args: opt!(varargslist) >>
6363
spaces!() >>
@@ -221,10 +221,10 @@ named!(atom_expr<StrSpan, Box<Expression>>,
221221
do_parse!(
222222
lhs: call!(Self::atom) >>
223223
trailers: fold_many0!(
224-
ws3!(alt!(
225-
delimited!(char!('('), ws4!(call!(ExpressionParser::<NewlinesAreSpaces>::arglist)), char!(')')) => { |args| Trailer::Call(args) }
226-
| delimited!(char!('['), ws4!(separated_list!(char!(','), call!(ExpressionParser::<NewlinesAreSpaces>::subscript))), char!(']')) => { |i| Trailer::Subscript(i) }
227-
| preceded!(ws3!(char!('.')), name) => { |name| Trailer::Attribute(name) }
224+
ws_auto!(alt!(
225+
delimited!(char!('('), ws_comm!(call!(ExpressionParser::<NewlinesAreSpaces>::arglist)), char!(')')) => { |args| Trailer::Call(args) }
226+
| delimited!(char!('['), ws_comm!(separated_list!(char!(','), call!(ExpressionParser::<NewlinesAreSpaces>::subscript))), char!(']')) => { |i| Trailer::Subscript(i) }
227+
| preceded!(ws_auto!(char!('.')), name) => { |name| Trailer::Attribute(name) }
228228
)),
229229
lhs,
230230
|acc, item| Box::new(match item {
@@ -256,13 +256,13 @@ named!(atom<StrSpan, Box<Expression>>,
256256
}}
257257
| number
258258
| name => { |n| Expression::Name(n) }
259-
| tuple!(char!('['), ws4!(opt!(char!(' '))), char!(']')) => { |_| Expression::ListLiteral(vec![]) }
260-
| tuple!(char!('{'), ws4!(opt!(char!(' '))), char!('}')) => { |_| Expression::DictLiteral(vec![]) }
261-
| tuple!(char!('('), ws4!(opt!(char!(' '))), char!(')')) => { |_| Expression::TupleLiteral(vec![]) }
262-
| delimited!(char!('{'), ws4!(map!(
259+
| tuple!(char!('['), ws_comm!(opt!(char!(' '))), char!(']')) => { |_| Expression::ListLiteral(vec![]) }
260+
| tuple!(char!('{'), ws_comm!(opt!(char!(' '))), char!('}')) => { |_| Expression::DictLiteral(vec![]) }
261+
| tuple!(char!('('), ws_comm!(opt!(char!(' '))), char!(')')) => { |_| Expression::TupleLiteral(vec![]) }
262+
| delimited!(char!('{'), ws_comm!(map!(
263263
call!(ExpressionParser::<NewlinesAreSpaces>::dictorsetmaker), |e:Box<_>| *e
264264
)), char!('}'))
265-
| map_opt!(ws3!(delimited!(char!('('), ws4!(
265+
| map_opt!(ws_auto!(delimited!(char!('('), ws_comm!(
266266
call!(ExpressionParser::<NewlinesAreSpaces>::testlist_comp)
267267
), char!(')'))), |ret| {
268268
match ret {
@@ -276,10 +276,10 @@ named!(atom<StrSpan, Box<Expression>>,
276276
TestlistCompReturn::Single(SetItem::Star(_)) => None,
277277
}
278278
})
279-
| delimited!(char!('('), ws4!(
279+
| delimited!(char!('('), ws_comm!(
280280
call!(ExpressionParser::<NewlinesAreSpaces>::yield_expr)
281281
), char!(')'))
282-
| delimited!(char!('['), ws4!(
282+
| delimited!(char!('['), ws_comm!(
283283
call!(ExpressionParser::<NewlinesAreSpaces>::testlist_comp)
284284
), char!(']')) => { |ret| {
285285
match ret {
@@ -294,21 +294,21 @@ named!(atom<StrSpan, Box<Expression>>,
294294
// testlist_comp: (test|star_expr) ( comp_for | (',' (test|star_expr))* [','] )
295295
named!(testlist_comp<StrSpan, TestlistCompReturn>,
296296
do_parse!(
297-
first: ws3!(alt!(
297+
first: ws_auto!(alt!(
298298
call!(Self::test) => { |e: Box<_>| SetItem::Unique(*e) }
299299
| preceded!(char!('*'), call!(Self::expr)) => { |e: Box<_>| SetItem::Star(*e) }
300300
)) >>
301301
r: alt!(
302302
call!(Self::comp_for) => { |comp| TestlistCompReturn::Comp(Box::new(first), comp) }
303303
| opt!(delimited!(
304-
ws3!(char!(',')),
305-
separated_list!(ws3!(char!(',')),
304+
ws_auto!(char!(',')),
305+
separated_list!(ws_auto!(char!(',')),
306306
alt!(
307307
call!(Self::test) => { |e: Box<_>| SetItem::Unique(*e) }
308308
| preceded!(char!('*'), call!(Self::expr)) => { |e: Box<_>| SetItem::Star(*e) }
309309
)
310310
),
311-
ws3!(opt!(char!(',')))
311+
ws_auto!(opt!(char!(',')))
312312
)) => { |v: Option<Vec<SetItem>>| {
313313
match v {
314314
Some(v) => {
@@ -327,11 +327,11 @@ named!(testlist_comp<StrSpan, TestlistCompReturn>,
327327

328328
// subscript: test | [test] ':' [test] [sliceop]
329329
named!(subscript<StrSpan, Subscript>,
330-
ws4!(alt!(
330+
ws_comm!(alt!(
331331
preceded!(char!(':'), call!(Self::subscript_trail, None))
332332
| do_parse!(
333333
first: call!(Self::test) >>
334-
r: opt!(ws4!(preceded!(char!(':'), call!(Self::subscript_trail, Some(*first.clone()))))) >> ( // FIXME: remove this clone
334+
r: opt!(ws_comm!(preceded!(char!(':'), call!(Self::subscript_trail, Some(*first.clone()))))) >> ( // FIXME: remove this clone
335335
r.unwrap_or(Subscript::Simple(*first))
336336
)
337337
)
@@ -353,18 +353,18 @@ named_args!(subscript_trail(first: Option<Expression>) <StrSpan, Subscript>,
353353

354354
// exprlist: (expr|star_expr) (',' (expr|star_expr))* [',']
355355
named!(pub exprlist<StrSpan, Vec<Expression>>,
356-
separated_nonempty_list!(ws3!(char!(',')), map!(alt!(call!(Self::expr)|call!(Self::star_expr)), |e| *e))
356+
separated_nonempty_list!(ws_auto!(char!(',')), map!(alt!(call!(Self::expr)|call!(Self::star_expr)), |e| *e))
357357
);
358358

359359
// testlist: test (',' test)* [',']
360360
named!(pub testlist<StrSpan, Vec<Expression>>,
361-
separated_nonempty_list!(ws3!(char!(',')), map!(call!(Self::test), |e| *e))
361+
separated_nonempty_list!(ws_auto!(char!(',')), map!(call!(Self::test), |e| *e))
362362
);
363363

364364
// FIXME: the code of this function is unreadable
365365
named!(pub possibly_empty_testlist<StrSpan, Vec<Expression>>,
366366
alt!(
367-
tuple!(separated_nonempty_list!(ws3!(char!(',')), map!(call!(Self::test), |e:Box<_>| *e)), opt!(ws3!(char!(',')))) => { |(mut e, comma):(Vec<_>, _)|
367+
tuple!(separated_nonempty_list!(ws_auto!(char!(',')), map!(call!(Self::test), |e:Box<_>| *e)), opt!(ws_auto!(char!(',')))) => { |(mut e, comma):(Vec<_>, _)|
368368
match (e.len(), comma) {
369369
(0, _) => unreachable!(),
370370
(1, Some(_)) => vec![Expression::TupleLiteral(vec![SetItem::Unique(e.remove(0))])], // The remove can't panic, because len == 1
@@ -389,7 +389,7 @@ impl ExpressionParser<NewlinesAreSpaces> {
389389
// ((test | star_expr)
390390
// (comp_for | (',' (test | star_expr))* [','])) )
391391
named!(dictorsetmaker<StrSpan, Box<Expression>>,
392-
ws4!(alt!(
392+
ws_comm!(alt!(
393393
do_parse!(
394394
tag!("**") >>
395395
e: map!(call!(Self::expr), |e: Box<_>| DictItem::Star(*e)) >>
@@ -421,7 +421,7 @@ named!(dictorsetmaker<StrSpan, Box<Expression>>,
421421
named_args!(dictmaker(item1: DictItem) <StrSpan, Box<Expression>>,
422422
map!(
423423
opt!(alt!(
424-
ws4!(delimited!(char!(','), separated_list!(char!(','), call!(Self::dictitem)), opt!(ws4!(char!(','))))) => { |v: Vec<_>| {
424+
ws_comm!(delimited!(char!(','), separated_list!(char!(','), call!(Self::dictitem)), opt!(ws_comm!(char!(','))))) => { |v: Vec<_>| {
425425
let mut v = v;
426426
v.insert(0, item1.clone()); // FIXME: do not clone
427427
Box::new(Expression::DictLiteral(v))
@@ -442,7 +442,7 @@ named_args!(dictmaker(item1: DictItem) <StrSpan, Box<Expression>>,
442442
named_args!(setmaker(item1: SetItem) <StrSpan, Box<Expression>>,
443443
do_parse!(
444444
rest:opt!(alt!(
445-
ws4!(delimited!(char!(','), separated_list!(char!(','), call!(Self::setitem)), opt!(ws4!(char!(','))))) => { |v: Vec<_>| {
445+
ws_comm!(delimited!(char!(','), separated_list!(char!(','), call!(Self::setitem)), opt!(ws_comm!(char!(','))))) => { |v: Vec<_>| {
446446
let mut v = v;
447447
v.insert(0, item1.clone()); // FIXME: do not clone
448448
Box::new(Expression::SetLiteral(v))
@@ -460,14 +460,14 @@ named_args!(setmaker(item1: SetItem) <StrSpan, Box<Expression>>,
460460
);
461461

462462
named!(dictitem<StrSpan, DictItem>,
463-
ws4!(alt!(
463+
ws_comm!(alt!(
464464
preceded!(tag!("**"), call!(Self::expr)) => { |e:Box<_>| DictItem::Star(*e) }
465465
| tuple!(call!(Self::test), char!(':'), call!(Self::test)) => { |(e1,_,e2): (Box<_>,_,Box<_>)| DictItem::Unique(*e1,*e2) }
466466
))
467467
);
468468

469469
named!(setitem<StrSpan, SetItem>,
470-
ws4!(alt!(
470+
ws_comm!(alt!(
471471
preceded!(tag!("*"), call!(Self::expr)) => { |e:Box<_>| SetItem::Star(*e) }
472472
|call!(Self::test) => { |e:Box<_>| SetItem::Unique(*e) }
473473
))
@@ -489,8 +489,8 @@ impl<ANS: AreNewlinesSpaces> ExpressionParser<ANS> {
489489
// '**' test |
490490
// '*' test )
491491
named!(pub arglist<StrSpan, Vec<Argument>>,
492-
ws4!(do_parse!(
493-
args: separated_list!(ws4!(char!(',')),
492+
ws_comm!(do_parse!(
493+
args: separated_list!(ws_comm!(char!(',')),
494494
alt!(
495495
preceded!(tag!("**"), call!(Self::test)) => { |kwargs: Box<_>| Argument::Kwargs(*kwargs) }
496496
| preceded!(char!('*'), call!(Self::test)) => { |args: Box<_>| Argument::Starargs(*args) }
@@ -502,7 +502,7 @@ named!(pub arglist<StrSpan, Vec<Argument>>,
502502
)
503503
| do_parse!(
504504
test1: call!(Self::test) >>
505-
next: opt!(ws4!(alt!(call!(Self::comp_for)))) >> (
505+
next: opt!(ws_comm!(alt!(call!(Self::comp_for)))) >> (
506506
match next {
507507
Some(e) => Argument::Positional(Expression::Generator(Box::new(SetItem::Unique(*test1)), e)),
508508
None => Argument::Positional(*test1)
@@ -511,7 +511,7 @@ named!(pub arglist<StrSpan, Vec<Argument>>,
511511
)
512512
)
513513
) >>
514-
opt!(ws4!(char!(','))) >>
514+
opt!(ws_comm!(char!(','))) >>
515515
(args)
516516
))
517517
);
@@ -570,10 +570,10 @@ named_args!(comp_if(acc: Vec<ComprehensionChunk>) <StrSpan, Vec<ComprehensionChu
570570
// yield_expr: 'yield' [yield_arg]
571571
// yield_arg: 'from' test | testlist
572572
named!(pub yield_expr<StrSpan, Expression>,
573-
ws3!(preceded!(
573+
ws_auto!(preceded!(
574574
keyword!("yield"),
575-
ws3!(alt!(
576-
preceded!(ws3!(keyword!("from")), call!(Self::test)) => { |e| Expression::YieldFrom(e) }
575+
ws_auto!(alt!(
576+
preceded!(ws_auto!(keyword!("from")), call!(Self::test)) => { |e| Expression::YieldFrom(e) }
577577
| call!(Self::testlist) => { |e| Expression::Yield(e) }
578578
| tag!("") => { |_| Expression::Yield(Vec::new()) }
579579
))

‎src/functions.rs

Lines changed: 24 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -16,8 +16,8 @@ named_args!(decorator(indent: usize) <StrSpan, Decorator>,
1616
do_parse!(
1717
count!(char!(' '), indent) >>
1818
char!('@') >>
19-
name: ws2!(call!(ImportParser::<NewlinesAreNotSpaces>::dotted_name)) >>
20-
args: opt!(ws2!(delimited!(char!('('), ws4!(call!(ExpressionParser::<NewlinesAreSpaces>::arglist)), char!(')')))) >>
19+
name: ws_nonl!(call!(ImportParser::<NewlinesAreNotSpaces>::dotted_name)) >>
20+
args: opt!(ws_nonl!(delimited!(char!('('), ws_comm!(call!(ExpressionParser::<NewlinesAreSpaces>::arglist)), char!(')')))) >>
2121
newline >> (
2222
Decorator { name, args }
2323
)
@@ -33,7 +33,7 @@ named_args!(decorators(indent: usize) <StrSpan, Vec<Decorator>>,
3333
named_args!(pub decorated(indent: usize) <StrSpan, CompoundStatement>,
3434
do_parse!(
3535
decorators: call!(decorators, indent) >>
36-
s: switch!(peek!(ws2!(first_word)),
36+
s: switch!(peek!(ws_nonl!(first_word)),
3737
"def" => call!(funcdef, indent, decorators.clone()) // FIXME: do not clone
3838
| "async" => call!(funcdef, indent, decorators.clone()) // FIXME: do not clone
3939
| "class" => call!(classdef, indent, decorators)
@@ -50,13 +50,13 @@ named_args!(pub decorated(indent: usize) <StrSpan, CompoundStatement>,
5050
named_args!(funcdef(indent: usize, decorators: Vec<Decorator>) <StrSpan, CompoundStatement>,
5151
do_parse!(
5252
count!(char!(' '), indent) >>
53-
async: opt!(tuple!(tag!("async"), space_sep2)) >>
53+
async: opt!(tuple!(tag!("async"), space_sep_nonl)) >>
5454
tag!("def") >>
55-
space_sep2 >>
55+
space_sep_nonl >>
5656
name: name >>
57-
parameters: ws2!(parameters) >>
58-
return_type: opt!(ws2!(preceded!(tag!("->"), call!(ExpressionParser::<NewlinesAreNotSpaces>::test)))) >>
59-
ws2!(char!(':')) >>
57+
parameters: ws_nonl!(parameters) >>
58+
return_type: opt!(ws_nonl!(preceded!(tag!("->"), call!(ExpressionParser::<NewlinesAreNotSpaces>::test)))) >>
59+
ws_nonl!(char!(':')) >>
6060
code: call!(block, indent) >> (
6161
CompoundStatement::Funcdef(Funcdef {
6262
async: async.is_some(), decorators, name, parameters, return_type: return_type.map(|t| *t), code
@@ -70,11 +70,11 @@ named_args!(classdef(indent: usize, decorators: Vec<Decorator>) <StrSpan, Compou
7070
do_parse!(
7171
count!(char!(' '), indent) >>
7272
tag!("class") >>
73-
space_sep2 >>
73+
space_sep_nonl >>
7474
name: name >>
75-
spaces >>
76-
arguments: opt!(ws2!(delimited!(char!('('), ws4!(call!(ExpressionParser::<NewlinesAreSpaces>::arglist)), char!(')')))) >>
77-
ws2!(char!(':')) >>
75+
spaces_nonl >>
76+
arguments: opt!(ws_nonl!(delimited!(char!('('), ws_comm!(call!(ExpressionParser::<NewlinesAreSpaces>::arglist)), char!(')')))) >>
77+
ws_nonl!(char!(':')) >>
7878
code: call!(block, indent) >> (
7979
CompoundStatement::Classdef(Classdef {
8080
decorators, name, arguments: arguments.unwrap_or_default(), code
@@ -94,11 +94,11 @@ trait IsItTyped {
9494
fn fpdef<'a>(input: StrSpan<'a>) -> IResult<StrSpan<'a>, Self::Return, u32>;
9595

9696
fn fpdef_with_default<'a>(i: StrSpan<'a>) -> IResult<StrSpan<'a>, (Self::Return, Option<Box<Expression>>), u32> {
97-
ws4!(i, tuple!(
97+
ws_comm!(i, tuple!(
9898
Self::fpdef,
9999
opt!(
100100
preceded!(
101-
ws4!(char!('=')),
101+
ws_comm!(char!('=')),
102102
call!(ExpressionParser::<NewlinesAreSpaces>::test)
103103
)
104104
)
@@ -115,8 +115,8 @@ impl IsItTyped for Typed {
115115
type List = TypedArgsList;
116116

117117
named!(fpdef<StrSpan, Self::Return>,
118-
ws4!(tuple!(name,
119-
opt!(ws4!(preceded!(char!(':'), call!(ExpressionParser::<NewlinesAreSpaces>::test))))
118+
ws_comm!(tuple!(name,
119+
opt!(ws_comm!(preceded!(char!(':'), call!(ExpressionParser::<NewlinesAreSpaces>::test))))
120120
))
121121
);
122122

@@ -170,7 +170,7 @@ impl IsItTyped for Untyped {
170170

171171
// parameters: '(' [typedargslist] ')'
172172
named!(parameters<StrSpan, TypedArgsList>,
173-
map!(delimited!(char!('('), opt!(ws4!(typedargslist)), char!(')')), |o| o.unwrap_or_default())
173+
map!(delimited!(char!('('), opt!(ws_comm!(typedargslist)), char!(')')), |o| o.unwrap_or_default())
174174
);
175175

176176
// typedargslist: (tfpdef ['=' test] (',' tfpdef ['=' test])* [',' [
@@ -194,7 +194,7 @@ struct ParamlistParser<IIT: IsItTyped> {
194194
phantom: PhantomData<IIT>
195195
}
196196
impl<IIT: IsItTyped> ParamlistParser<IIT> {
197-
named!(parse<StrSpan, IIT::List>, ws4!(
197+
named!(parse<StrSpan, IIT::List>, ws_comm!(
198198
alt!(
199199
/***************************
200200
* Case 1: only **kwargs
@@ -213,8 +213,8 @@ impl<IIT: IsItTyped> ParamlistParser<IIT> {
213213
tag!("*") >>
214214
star_args: opt!(call!(IIT::fpdef)) >>
215215
keyword_args: many0!(preceded!(char!(','), call!(IIT::fpdef_with_default))) >>
216-
star_kwargs: opt!(ws4!(preceded!(char!(','), opt!(ws4!(preceded!(tag!("**"), call!(IIT::fpdef))))))) >>
217-
opt!(ws4!(char!(','))) >> (
216+
star_kwargs: opt!(ws_comm!(preceded!(char!(','), opt!(ws_comm!(preceded!(tag!("**"), call!(IIT::fpdef))))))) >>
217+
opt!(ws_comm!(char!(','))) >> (
218218
IIT::make_list(Vec::new(), Some(star_args), keyword_args, star_kwargs.unwrap_or(None))
219219
)
220220
)
@@ -228,8 +228,8 @@ impl<IIT: IsItTyped> ParamlistParser<IIT> {
228228
* Parse positional arguments:
229229
* tfpdef ['=' test] (',' tfpdef ['=' test])*
230230
*/
231-
positional_args: separated_nonempty_list!(ws4!(char!(',')), call!(IIT::fpdef_with_default)) >>
232-
r: opt!(ws4!(preceded!(char!(','), opt!(ws4!(
231+
positional_args: separated_nonempty_list!(ws_comm!(char!(',')), call!(IIT::fpdef_with_default)) >>
232+
r: opt!(ws_comm!(preceded!(char!(','), opt!(ws_comm!(
233233

234234
alt!(
235235
/************
@@ -247,8 +247,8 @@ impl<IIT: IsItTyped> ParamlistParser<IIT> {
247247
| do_parse!(
248248
char!('*') >>
249249
star_args: opt!(call!(IIT::fpdef)) >>
250-
keyword_args: opt!(ws4!(preceded!(char!(','), separated_nonempty_list!(ws4!(char!(',')), call!(IIT::fpdef_with_default))))) >>
251-
star_kwargs: opt!(ws4!(preceded!(char!(','), opt!(preceded!(tag!("**"), call!(IIT::fpdef)))))) >> ( // FIXME: ws! is needed here because it does not traverse opt!
250+
keyword_args: opt!(ws_comm!(preceded!(char!(','), separated_nonempty_list!(ws_comm!(char!(',')), call!(IIT::fpdef_with_default))))) >>
251+
star_kwargs: opt!(ws_comm!(preceded!(char!(','), opt!(preceded!(tag!("**"), call!(IIT::fpdef)))))) >> ( // FIXME: ws! is needed here because it does not traverse opt!
252252
IIT::make_list(positional_args.clone(), Some(star_args), keyword_args.unwrap_or(Vec::new()), star_kwargs.unwrap_or(None)) // FIXME: do not clone
253253
)
254254
)

0 commit comments

Comments
 (0)