Skip to content

Commit

Permalink
Use better names for spacing-related helpers.
Browse files Browse the repository at this point in the history
  • Loading branch information
@progval
progval committed Jun 17, 2018
1 parent 1d7ea49 commit a025ea2
Show file tree
Hide file tree
Showing 6 changed files with 130 additions and 129 deletions.
70 changes: 35 additions & 35 deletions src/expressions.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -31,9 +31,9 @@ named!(pub test<StrSpan, Box<Expression>>,
| do_parse!(
left: call!(Self::or_test) >>
right: opt!(do_parse!(
ws3!(keyword!("if")) >>
ws_auto!(keyword!("if")) >>
cond: call!(Self::or_test) >>
ws3!(keyword!("else")) >>
ws_auto!(keyword!("else")) >>
right: call!(Self::test) >> (
(cond, right)
)
Expand All @@ -57,7 +57,7 @@ named!(test_nocond<StrSpan, Box<Expression>>,

// lambdef: 'lambda' [varargslist] ':' test
named!(lambdef<StrSpan, Box<Expression>>,
ws3!(do_parse!(
ws_auto!(do_parse!(
keyword!("lambda") >>
args: opt!(varargslist) >>
spaces!() >>
Expand Down Expand Up @@ -221,10 +221,10 @@ named!(atom_expr<StrSpan, Box<Expression>>,
do_parse!(
lhs: call!(Self::atom) >>
trailers: fold_many0!(
ws3!(alt!(
delimited!(char!('('), ws4!(call!(ExpressionParser::<NewlinesAreSpaces>::arglist)), char!(')')) => { |args| Trailer::Call(args) }
| delimited!(char!('['), ws4!(separated_list!(char!(','), call!(ExpressionParser::<NewlinesAreSpaces>::subscript))), char!(']')) => { |i| Trailer::Subscript(i) }
| preceded!(ws3!(char!('.')), name) => { |name| Trailer::Attribute(name) }
ws_auto!(alt!(
delimited!(char!('('), ws_comm!(call!(ExpressionParser::<NewlinesAreSpaces>::arglist)), char!(')')) => { |args| Trailer::Call(args) }
| delimited!(char!('['), ws_comm!(separated_list!(char!(','), call!(ExpressionParser::<NewlinesAreSpaces>::subscript))), char!(']')) => { |i| Trailer::Subscript(i) }
| preceded!(ws_auto!(char!('.')), name) => { |name| Trailer::Attribute(name) }
)),
lhs,
|acc, item| Box::new(match item {
Expand Down Expand Up @@ -256,13 +256,13 @@ named!(atom<StrSpan, Box<Expression>>,
}}
| number
| name => { |n| Expression::Name(n) }
| tuple!(char!('['), ws4!(opt!(char!(' '))), char!(']')) => { |_| Expression::ListLiteral(vec![]) }
| tuple!(char!('{'), ws4!(opt!(char!(' '))), char!('}')) => { |_| Expression::DictLiteral(vec![]) }
| tuple!(char!('('), ws4!(opt!(char!(' '))), char!(')')) => { |_| Expression::TupleLiteral(vec![]) }
| delimited!(char!('{'), ws4!(map!(
| tuple!(char!('['), ws_comm!(opt!(char!(' '))), char!(']')) => { |_| Expression::ListLiteral(vec![]) }
| tuple!(char!('{'), ws_comm!(opt!(char!(' '))), char!('}')) => { |_| Expression::DictLiteral(vec![]) }
| tuple!(char!('('), ws_comm!(opt!(char!(' '))), char!(')')) => { |_| Expression::TupleLiteral(vec![]) }
| delimited!(char!('{'), ws_comm!(map!(
call!(ExpressionParser::<NewlinesAreSpaces>::dictorsetmaker), |e:Box<_>| *e
)), char!('}'))
| map_opt!(ws3!(delimited!(char!('('), ws4!(
| map_opt!(ws_auto!(delimited!(char!('('), ws_comm!(
call!(ExpressionParser::<NewlinesAreSpaces>::testlist_comp)
), char!(')'))), |ret| {
match ret {
Expand All @@ -276,10 +276,10 @@ named!(atom<StrSpan, Box<Expression>>,
TestlistCompReturn::Single(SetItem::Star(_)) => None,
}
})
| delimited!(char!('('), ws4!(
| delimited!(char!('('), ws_comm!(
call!(ExpressionParser::<NewlinesAreSpaces>::yield_expr)
), char!(')'))
| delimited!(char!('['), ws4!(
| delimited!(char!('['), ws_comm!(
call!(ExpressionParser::<NewlinesAreSpaces>::testlist_comp)
), char!(']')) => { |ret| {
match ret {
Expand All @@ -294,21 +294,21 @@ named!(atom<StrSpan, Box<Expression>>,
// testlist_comp: (test|star_expr) ( comp_for | (',' (test|star_expr))* [','] )
named!(testlist_comp<StrSpan, TestlistCompReturn>,
do_parse!(
first: ws3!(alt!(
first: ws_auto!(alt!(
call!(Self::test) => { |e: Box<_>| SetItem::Unique(*e) }
| preceded!(char!('*'), call!(Self::expr)) => { |e: Box<_>| SetItem::Star(*e) }
)) >>
r: alt!(
call!(Self::comp_for) => { |comp| TestlistCompReturn::Comp(Box::new(first), comp) }
| opt!(delimited!(
ws3!(char!(',')),
separated_list!(ws3!(char!(',')),
ws_auto!(char!(',')),
separated_list!(ws_auto!(char!(',')),
alt!(
call!(Self::test) => { |e: Box<_>| SetItem::Unique(*e) }
| preceded!(char!('*'), call!(Self::expr)) => { |e: Box<_>| SetItem::Star(*e) }
)
),
ws3!(opt!(char!(',')))
ws_auto!(opt!(char!(',')))
)) => { |v: Option<Vec<SetItem>>| {
match v {
Some(v) => {
Expand All @@ -327,11 +327,11 @@ named!(testlist_comp<StrSpan, TestlistCompReturn>,

// subscript: test | [test] ':' [test] [sliceop]
named!(subscript<StrSpan, Subscript>,
ws4!(alt!(
ws_comm!(alt!(
preceded!(char!(':'), call!(Self::subscript_trail, None))
| do_parse!(
first: call!(Self::test) >>
r: opt!(ws4!(preceded!(char!(':'), call!(Self::subscript_trail, Some(*first.clone()))))) >> ( // FIXME: remove this clone
r: opt!(ws_comm!(preceded!(char!(':'), call!(Self::subscript_trail, Some(*first.clone()))))) >> ( // FIXME: remove this clone
r.unwrap_or(Subscript::Simple(*first))
)
)
Expand All @@ -353,18 +353,18 @@ named_args!(subscript_trail(first: Option<Expression>) <StrSpan, Subscript>,

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

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

// FIXME: the code of this function is unreadable
named!(pub possibly_empty_testlist<StrSpan, Vec<Expression>>,
alt!(
tuple!(separated_nonempty_list!(ws3!(char!(',')), map!(call!(Self::test), |e:Box<_>| *e)), opt!(ws3!(char!(',')))) => { |(mut e, comma):(Vec<_>, _)|
tuple!(separated_nonempty_list!(ws_auto!(char!(',')), map!(call!(Self::test), |e:Box<_>| *e)), opt!(ws_auto!(char!(',')))) => { |(mut e, comma):(Vec<_>, _)|
match (e.len(), comma) {
(0, _) => unreachable!(),
(1, Some(_)) => vec![Expression::TupleLiteral(vec![SetItem::Unique(e.remove(0))])], // The remove can't panic, because len == 1
Expand All @@ -389,7 +389,7 @@ impl ExpressionParser<NewlinesAreSpaces> {
// ((test | star_expr)
// (comp_for | (',' (test | star_expr))* [','])) )
named!(dictorsetmaker<StrSpan, Box<Expression>>,
ws4!(alt!(
ws_comm!(alt!(
do_parse!(
tag!("**") >>
e: map!(call!(Self::expr), |e: Box<_>| DictItem::Star(*e)) >>
Expand Down Expand Up @@ -421,7 +421,7 @@ named!(dictorsetmaker<StrSpan, Box<Expression>>,
named_args!(dictmaker(item1: DictItem) <StrSpan, Box<Expression>>,
map!(
opt!(alt!(
ws4!(delimited!(char!(','), separated_list!(char!(','), call!(Self::dictitem)), opt!(ws4!(char!(','))))) => { |v: Vec<_>| {
ws_comm!(delimited!(char!(','), separated_list!(char!(','), call!(Self::dictitem)), opt!(ws_comm!(char!(','))))) => { |v: Vec<_>| {
let mut v = v;
v.insert(0, item1.clone()); // FIXME: do not clone
Box::new(Expression::DictLiteral(v))
Expand All @@ -442,7 +442,7 @@ named_args!(dictmaker(item1: DictItem) <StrSpan, Box<Expression>>,
named_args!(setmaker(item1: SetItem) <StrSpan, Box<Expression>>,
do_parse!(
rest:opt!(alt!(
ws4!(delimited!(char!(','), separated_list!(char!(','), call!(Self::setitem)), opt!(ws4!(char!(','))))) => { |v: Vec<_>| {
ws_comm!(delimited!(char!(','), separated_list!(char!(','), call!(Self::setitem)), opt!(ws_comm!(char!(','))))) => { |v: Vec<_>| {
let mut v = v;
v.insert(0, item1.clone()); // FIXME: do not clone
Box::new(Expression::SetLiteral(v))
Expand All @@ -460,14 +460,14 @@ named_args!(setmaker(item1: SetItem) <StrSpan, Box<Expression>>,
);

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

named!(setitem<StrSpan, SetItem>,
ws4!(alt!(
ws_comm!(alt!(
preceded!(tag!("*"), call!(Self::expr)) => { |e:Box<_>| SetItem::Star(*e) }
|call!(Self::test) => { |e:Box<_>| SetItem::Unique(*e) }
))
Expand All @@ -489,8 +489,8 @@ impl<ANS: AreNewlinesSpaces> ExpressionParser<ANS> {
// '**' test |
// '*' test )
named!(pub arglist<StrSpan, Vec<Argument>>,
ws4!(do_parse!(
args: separated_list!(ws4!(char!(',')),
ws_comm!(do_parse!(
args: separated_list!(ws_comm!(char!(',')),
alt!(
preceded!(tag!("**"), call!(Self::test)) => { |kwargs: Box<_>| Argument::Kwargs(*kwargs) }
| preceded!(char!('*'), call!(Self::test)) => { |args: Box<_>| Argument::Starargs(*args) }
Expand All @@ -502,7 +502,7 @@ named!(pub arglist<StrSpan, Vec<Argument>>,
)
| do_parse!(
test1: call!(Self::test) >>
next: opt!(ws4!(alt!(call!(Self::comp_for)))) >> (
next: opt!(ws_comm!(alt!(call!(Self::comp_for)))) >> (
match next {
Some(e) => Argument::Positional(Expression::Generator(Box::new(SetItem::Unique(*test1)), e)),
None => Argument::Positional(*test1)
Expand All @@ -511,7 +511,7 @@ named!(pub arglist<StrSpan, Vec<Argument>>,
)
)
) >>
opt!(ws4!(char!(','))) >>
opt!(ws_comm!(char!(','))) >>
(args)
))
);
Expand Down Expand Up @@ -570,10 +570,10 @@ named_args!(comp_if(acc: Vec<ComprehensionChunk>) <StrSpan, Vec<ComprehensionChu
// yield_expr: 'yield' [yield_arg]
// yield_arg: 'from' test | testlist
named!(pub yield_expr<StrSpan, Expression>,
ws3!(preceded!(
ws_auto!(preceded!(
keyword!("yield"),
ws3!(alt!(
preceded!(ws3!(keyword!("from")), call!(Self::test)) => { |e| Expression::YieldFrom(e) }
ws_auto!(alt!(
preceded!(ws_auto!(keyword!("from")), call!(Self::test)) => { |e| Expression::YieldFrom(e) }
| call!(Self::testlist) => { |e| Expression::Yield(e) }
| tag!("") => { |_| Expression::Yield(Vec::new()) }
))
Expand Down
48 changes: 24 additions & 24 deletions src/functions.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -16,8 +16,8 @@ named_args!(decorator(indent: usize) <StrSpan, Decorator>,
do_parse!(
count!(char!(' '), indent) >>
char!('@') >>
name: ws2!(call!(ImportParser::<NewlinesAreNotSpaces>::dotted_name)) >>
args: opt!(ws2!(delimited!(char!('('), ws4!(call!(ExpressionParser::<NewlinesAreSpaces>::arglist)), char!(')')))) >>
name: ws_nonl!(call!(ImportParser::<NewlinesAreNotSpaces>::dotted_name)) >>
args: opt!(ws_nonl!(delimited!(char!('('), ws_comm!(call!(ExpressionParser::<NewlinesAreSpaces>::arglist)), char!(')')))) >>
newline >> (
Decorator { name, args }
)
Expand All @@ -33,7 +33,7 @@ named_args!(decorators(indent: usize) <StrSpan, Vec<Decorator>>,
named_args!(pub decorated(indent: usize) <StrSpan, CompoundStatement>,
do_parse!(
decorators: call!(decorators, indent) >>
s: switch!(peek!(ws2!(first_word)),
s: switch!(peek!(ws_nonl!(first_word)),
"def" => call!(funcdef, indent, decorators.clone()) // FIXME: do not clone
| "async" => call!(funcdef, indent, decorators.clone()) // FIXME: do not clone
| "class" => call!(classdef, indent, decorators)
Expand All @@ -50,13 +50,13 @@ named_args!(pub decorated(indent: usize) <StrSpan, CompoundStatement>,
named_args!(funcdef(indent: usize, decorators: Vec<Decorator>) <StrSpan, CompoundStatement>,
do_parse!(
count!(char!(' '), indent) >>
async: opt!(tuple!(tag!("async"), space_sep2)) >>
async: opt!(tuple!(tag!("async"), space_sep_nonl)) >>
tag!("def") >>
space_sep2 >>
space_sep_nonl >>
name: name >>
parameters: ws2!(parameters) >>
return_type: opt!(ws2!(preceded!(tag!("->"), call!(ExpressionParser::<NewlinesAreNotSpaces>::test)))) >>
ws2!(char!(':')) >>
parameters: ws_nonl!(parameters) >>
return_type: opt!(ws_nonl!(preceded!(tag!("->"), call!(ExpressionParser::<NewlinesAreNotSpaces>::test)))) >>
ws_nonl!(char!(':')) >>
code: call!(block, indent) >> (
CompoundStatement::Funcdef(Funcdef {
async: async.is_some(), decorators, name, parameters, return_type: return_type.map(|t| *t), code
Expand All @@ -70,11 +70,11 @@ named_args!(classdef(indent: usize, decorators: Vec<Decorator>) <StrSpan, Compou
do_parse!(
count!(char!(' '), indent) >>
tag!("class") >>
space_sep2 >>
space_sep_nonl >>
name: name >>
spaces >>
arguments: opt!(ws2!(delimited!(char!('('), ws4!(call!(ExpressionParser::<NewlinesAreSpaces>::arglist)), char!(')')))) >>
ws2!(char!(':')) >>
spaces_nonl >>
arguments: opt!(ws_nonl!(delimited!(char!('('), ws_comm!(call!(ExpressionParser::<NewlinesAreSpaces>::arglist)), char!(')')))) >>
ws_nonl!(char!(':')) >>
code: call!(block, indent) >> (
CompoundStatement::Classdef(Classdef {
decorators, name, arguments: arguments.unwrap_or_default(), code
Expand All @@ -94,11 +94,11 @@ trait IsItTyped {
fn fpdef<'a>(input: StrSpan<'a>) -> IResult<StrSpan<'a>, Self::Return, u32>;

fn fpdef_with_default<'a>(i: StrSpan<'a>) -> IResult<StrSpan<'a>, (Self::Return, Option<Box<Expression>>), u32> {
ws4!(i, tuple!(
ws_comm!(i, tuple!(
Self::fpdef,
opt!(
preceded!(
ws4!(char!('=')),
ws_comm!(char!('=')),
call!(ExpressionParser::<NewlinesAreSpaces>::test)
)
)
Expand All @@ -115,8 +115,8 @@ impl IsItTyped for Typed {
type List = TypedArgsList;

named!(fpdef<StrSpan, Self::Return>,
ws4!(tuple!(name,
opt!(ws4!(preceded!(char!(':'), call!(ExpressionParser::<NewlinesAreSpaces>::test))))
ws_comm!(tuple!(name,
opt!(ws_comm!(preceded!(char!(':'), call!(ExpressionParser::<NewlinesAreSpaces>::test))))
))
);

Expand Down Expand Up @@ -170,7 +170,7 @@ impl IsItTyped for Untyped {

// parameters: '(' [typedargslist] ')'
named!(parameters<StrSpan, TypedArgsList>,
map!(delimited!(char!('('), opt!(ws4!(typedargslist)), char!(')')), |o| o.unwrap_or_default())
map!(delimited!(char!('('), opt!(ws_comm!(typedargslist)), char!(')')), |o| o.unwrap_or_default())
);

// typedargslist: (tfpdef ['=' test] (',' tfpdef ['=' test])* [',' [
Expand All @@ -194,7 +194,7 @@ struct ParamlistParser<IIT: IsItTyped> {
phantom: PhantomData<IIT>
}
impl<IIT: IsItTyped> ParamlistParser<IIT> {
named!(parse<StrSpan, IIT::List>, ws4!(
named!(parse<StrSpan, IIT::List>, ws_comm!(
alt!(
/***************************
* Case 1: only **kwargs
Expand All @@ -213,8 +213,8 @@ impl<IIT: IsItTyped> ParamlistParser<IIT> {
tag!("*") >>
star_args: opt!(call!(IIT::fpdef)) >>
keyword_args: many0!(preceded!(char!(','), call!(IIT::fpdef_with_default))) >>
star_kwargs: opt!(ws4!(preceded!(char!(','), opt!(ws4!(preceded!(tag!("**"), call!(IIT::fpdef))))))) >>
opt!(ws4!(char!(','))) >> (
star_kwargs: opt!(ws_comm!(preceded!(char!(','), opt!(ws_comm!(preceded!(tag!("**"), call!(IIT::fpdef))))))) >>
opt!(ws_comm!(char!(','))) >> (
IIT::make_list(Vec::new(), Some(star_args), keyword_args, star_kwargs.unwrap_or(None))
)
)
Expand All @@ -228,8 +228,8 @@ impl<IIT: IsItTyped> ParamlistParser<IIT> {
* Parse positional arguments:
* tfpdef ['=' test] (',' tfpdef ['=' test])*
*/
positional_args: separated_nonempty_list!(ws4!(char!(',')), call!(IIT::fpdef_with_default)) >>
r: opt!(ws4!(preceded!(char!(','), opt!(ws4!(
positional_args: separated_nonempty_list!(ws_comm!(char!(',')), call!(IIT::fpdef_with_default)) >>
r: opt!(ws_comm!(preceded!(char!(','), opt!(ws_comm!(

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

0 comments on commit a025ea2

Please sign in to comment.