// See also: file:///usr/share/doc/python/html/reference/grammar.html?highlight=grammar

// See also: https://github.com/antlr/grammars-v4/blob/master/python3/Python3.g4

// See also: file:///usr/share/doc/python/html/reference/compound_stmts.html#function-definitions

// See also: https://greentreesnakes.readthedocs.io/en/latest/nodes.html#keyword

use crate::{

ast::{self as ast, Ranged},

lexer::{LexicalError, LexicalErrorType},

function::{ArgumentList, parse_args, parse_params, validate_arguments},

context::set_context,

string::parse_strings,

token::{self, StringKind},

text_size::TextSize, parser::optional_range

};

use num_bigint::BigInt;

grammar;

// This is a hack to reduce the amount of lalrpop tables generated:

// For each public entry point, a full parse table is generated.

// By having only a single pub function, we reduce this to one.

pub Top: ast::Mod = {

<start:@L> StartModule <body:Program> <end:@R> => ast::ModModule { body, type_ignores: vec![], range: optional_range(start, end) }.into(),

<start:@L> StartInteractive <body:Program> <end:@R> => ast::ModInteractive { body, range: optional_range(start, end) }.into(),

<start:@L> StartExpression <body:TestList> ("\n")* <end:@R> => ast::ModExpression { body: Box::new(body), range: optional_range(start, end) }.into()

};

Program: ast::Suite = {

=> vec![],

// Compound statements

<mut statements:Program> <next:CompoundStatement> => {

statements.push(next);

statements

},

// Small statements

<mut statements:Program> <small:(<SmallStatement> ";")*> <last:SmallStatement> ";"? "\n" => {

statements.extend(small);

statements.push(last);

statements

},

// Empty lines

<s:Program> "\n" => s,

};

Suite: ast::Suite = {

<mut statements:(<SmallStatement> ";")*> <last:SmallStatement> ";"? "\n" => {

statements.push(last);

statements

},

"\n" Indent <s:Statements> Dedent => s,

};

// One or more statements

Statements: Vec<ast::Stmt> = {

// First simple statement

<mut head:(<SmallStatement> ";")*> <last:SmallStatement> ";"? "\n" => {

head.push(last);

head

},

// The first compound statement

<s:CompoundStatement> => vec![s],

// Any subsequent compound statements

<mut statements:Statements> <next:CompoundStatement> => {

statements.push(next);

statements

},

// Any subsequent small statements

<mut statements:Statements> <small:(<SmallStatement> ";")*> <last:SmallStatement> ";"? "\n" => {

statements.extend(small);

statements.push(last);

statements

},

};

SmallStatement: ast::Stmt = {

ExpressionStatement,

PassStatement,

DelStatement,

FlowStatement,

ImportStatement,

GlobalStatement,

NonlocalStatement,

AssertStatement,

};

PassStatement: ast::Stmt = {

<location:@L> "pass" <end_location:@R> => {

ast::Stmt::Pass(ast::StmtPass { range: (location..end_location).into() })

},

};

DelStatement: ast::Stmt = {

<location:@L> "del" <targets:ExpressionList2> <end_location:@R> => {

ast::Stmt::Delete(

ast::StmtDelete { targets: targets.into_iter().map(|expr| set_context(expr, ast::ExprContext::Del)).collect(), range: (location..end_location).into() }

)

},

};

ExpressionStatement: ast::Stmt = {

<location:@L> <expression:TestOrStarExprList> <suffix:AssignSuffix*> <end_location:@R> => {

// Just an expression, no assignment:

if suffix.is_empty() {

ast::Stmt::Expr(

ast::StmtExpr { value: Box::new(expression), range: (location..end_location).into() }

)

} else {

let mut targets = vec![set_context(expression, ast::ExprContext::Store)];

let mut values = suffix;

let value = Box::new(values.pop().unwrap());

for target in values {

targets.push(set_context(target, ast::ExprContext::Store));

}

ast::Stmt::Assign(

ast::StmtAssign { targets, value, type_comment: None, range: (location..end_location).into() }

)

}

},

<location:@L> <target:TestOrStarExprList> <op:AugAssign> <rhs:TestListOrYieldExpr> <end_location:@R> => {

ast::Stmt::AugAssign(

ast::StmtAugAssign {

target: Box::new(set_context(target, ast::ExprContext::Store)),

op,

value: Box::new(rhs),

range: (location..end_location).into()

},

)

},

<location:@L> <target:Test<"all">> ":" <annotation:Test<"all">> <rhs:AssignSuffix?> <end_location:@R> => {

let simple = target.is_name_expr();

ast::Stmt::AnnAssign(

ast::StmtAnnAssign {

target: Box::new(set_context(target, ast::ExprContext::Store)),

annotation: Box::new(annotation),

value: rhs.map(Box::new),

simple,

range: (location..end_location).into()

},

)

},

};

AssignSuffix: ast::Expr = {

"=" <e:TestListOrYieldExpr> => e

};

TestListOrYieldExpr: ast::Expr = {

TestList,

YieldExpr

}

#[inline]

TestOrStarExprList: ast::Expr = {

// as far as I can tell, these were the same

TestList

};

TestOrStarExpr: ast::Expr = {

Test<"all">,

StarExpr,

};

NamedOrStarExpr: ast::Expr = {

NamedExpression,

StarExpr,

};

TestOrStarNamedExpr: ast::Expr = {

NamedExpressionTest,

StarExpr,

};

AugAssign: ast::Operator = {

"+=" => ast::Operator::Add,

"-=" => ast::Operator::Sub,

"*=" => ast::Operator::Mult,

"@=" => ast::Operator::MatMult,

"/=" => ast::Operator::Div,

"%=" => ast::Operator::Mod,

"&=" => ast::Operator::BitAnd,

"|=" => ast::Operator::BitOr,

"^=" => ast::Operator::BitXor,

"<<=" => ast::Operator::LShift,

">>=" => ast::Operator::RShift,

"**=" => ast::Operator::Pow,

"//=" => ast::Operator::FloorDiv,

};

FlowStatement: ast::Stmt = {

<location:@L> "break" <end_location:@R> => {

ast::Stmt::Break(ast::StmtBreak { range: (location..end_location).into() })

},

<location:@L> "continue" <end_location:@R> => {

ast::Stmt::Continue(ast::StmtContinue { range: (location..end_location).into() })

},

<location:@L> "return" <value:TestList?> <end_location:@R> => {

ast::Stmt::Return(

ast::StmtReturn { value: value.map(Box::new), range: (location..end_location).into() }

)

},

<location:@L> <expression:YieldExpr> <end_location:@R> => {

ast::Stmt::Expr(

ast::StmtExpr { value: Box::new(expression), range: (location..end_location).into() }

)

},

RaiseStatement,

};

RaiseStatement: ast::Stmt = {

<location:@L> "raise" <end_location:@R> => {

ast::Stmt::Raise(

ast::StmtRaise { exc: None, cause: None, range: (location..end_location).into() }

)

},

<location:@L> "raise" <t:Test<"all">> <c:("from" <Test<"all">>)?> <end_location:@R> => {

ast::Stmt::Raise(

ast::StmtRaise { exc: Some(Box::new(t)), cause: c.map(|x| Box::new(x)), range: (location..end_location).into() }

)

},

};

ImportStatement: ast::Stmt = {

<location:@L> "import" <names: OneOrMore<ImportAsAlias<DottedName>>> <end_location:@R> => {

ast::Stmt::Import(

ast::StmtImport { names, range: (location..end_location).into() }

)

},

<location:@L> "from" <source:ImportFromLocation> "import" <names: ImportAsNames> <end_location:@R> => {

let (level, module) = source;

ast::Stmt::ImportFrom(

ast::StmtImportFrom {

level,

module,

names,

range: (location..end_location).into()

},

)

},

};

ImportFromLocation: (Option<ast::Int>, Option<ast::Identifier>) = {

<dots: ImportDots*> <name:DottedName> => {

(Some(ast::Int::new(dots.iter().map(ast::Int::to_u32).sum())), Some(name))

},

<dots: ImportDots+> => {

(Some(ast::Int::new(dots.iter().map(ast::Int::to_u32).sum())), None)

},

};

ImportDots: ast::Int = {

"..." => ast::Int::new(3),

"." => ast::Int::new(1),

};

ImportAsNames: Vec<ast::Alias> = {

<location:@L> <i:OneOrMore<ImportAsAlias<Identifier>>> <end_location:@R> => i,

<location:@L> "(" <i:OneOrMore<ImportAsAlias<Identifier>>> ","? ")" <end_location:@R> => i,

<location:@L> "*" <end_location:@R> => {

// Star import all

vec![ast::Alias { name: ast::Identifier::new("*"), asname: None, range: (location..end_location).into() }]

},

};

#[inline]

ImportAsAlias<I>: ast::Alias = {

<location:@L> <name:I> <a: ("as" <Identifier>)?> <end_location:@R> => ast::Alias { name, asname: a, range: (location..end_location).into() },

}

// A name like abc or abc.def.ghi

DottedName: ast::Identifier = {

<n:name> => ast::Identifier::new(n),

<n:name> <n2: ("." Identifier)+> => {

let mut r = n.to_string();

for x in n2 {

r.push('.');

r.push_str(x.1.as_str());

}

ast::Identifier::new(r)

},

};

GlobalStatement: ast::Stmt = {

<location:@L> "global" <names:OneOrMore<Identifier>> <end_location:@R> => {

ast::Stmt::Global(

ast::StmtGlobal { names, range: (location..end_location).into() }

)

},

};

NonlocalStatement: ast::Stmt = {

<location:@L> "nonlocal" <names:OneOrMore<Identifier>> <end_location:@R> => {

ast::Stmt::Nonlocal(

ast::StmtNonlocal { names, range: (location..end_location).into() }

)

},

};

AssertStatement: ast::Stmt = {

<location:@L> "assert" <test:Test<"all">> <msg: ("," <Test<"all">>)?> <end_location:@R> => {

ast::Stmt::Assert(

ast::StmtAssert {

test: Box::new(test),

msg: msg.map(|e| Box::new(e)),

range: (location..end_location).into()

}

)

},

};

CompoundStatement: ast::Stmt = {

MatchStatement,

IfStatement,

WhileStatement,

ForStatement,

TryStatement,

WithStatement,

FuncDef,

ClassDef,

};

MatchStatement: ast::Stmt = {

<location:@L> "match" <subject:TestOrStarNamedExpr> ":" "\n" Indent <cases:MatchCase+> Dedent => {

let end_location = cases

.last()

.unwrap()

.body

.last()

.unwrap()

.end();

ast::Stmt::Match(

ast::StmtMatch {

subject: Box::new(subject),

cases,

range: (location..end_location).into()

}

)

},

<location:@L> "match" <subject:TestOrStarNamedExpr> "," ":" "\n" Indent <cases:MatchCase+> Dedent => {

let end_location = cases

.last()

.unwrap()

.body

.last()

.unwrap()

.end();

ast::Stmt::Match(

ast::StmtMatch {

subject: Box::new(subject),

cases,

range: (location..end_location).into()

}

)

},

<location:@L> "match" <subjects:TwoOrMore<TestOrStarNamedExpr, ",">> ","? ":" "\n" Indent <cases:MatchCase+> Dedent => {

let end_location = cases

.last()

.unwrap()

.body

.last()

.unwrap()

.end();

ast::Stmt::Match(

ast::StmtMatch {

subject: Box::new(ast::Expr::Tuple(

ast::ExprTuple {

elts: subjects,

ctx: ast::ExprContext::Load,

range: (location..end_location).into()

},

)),

cases,

range: (location..end_location).into()

}

)

}

}

MatchCase: ast::MatchCase = {

<start:@L> "case" <pattern:Patterns> <guard:(Guard)?> ":" <body:Suite> <end:@R> => {

ast::MatchCase {

pattern,

guard: guard.map(Box::new),

body,

range: optional_range(start, end)

}

},

}

Guard: ast::Expr = {

"if" <guard:NamedExpressionTest> => {

guard

}

}

Patterns: ast::Pattern = {

<location:@L> <pattern:Pattern> "," <end_location:@R> => ast::Pattern::MatchSequence(

ast::PatternMatchSequence {

patterns: vec![pattern],

range: (location..end_location).into()

},

),

<location:@L> <patterns:TwoOrMore<Pattern, ",">> ","? <end_location:@R> => {

ast::Pattern::MatchSequence(

ast::PatternMatchSequence {

patterns,

range: (location..end_location).into()

},

)

},

<pattern:Pattern> => pattern

}

Pattern: ast::Pattern = {

<pattern:AsPattern> => pattern,

<pattern:OrPattern> => pattern,

}

AsPattern: ast::Pattern = {

<location:@L> <pattern:OrPattern> "as" <name:Identifier> <end_location:@R> =>? {

if name.as_str() == "_" {

Err(LexicalError {

error: LexicalErrorType::OtherError("cannot use '_' as a target".to_string()),

location,

})?

} else {

Ok(ast::Pattern::MatchAs(

ast::PatternMatchAs {

pattern: Some(Box::new(pattern)),

name: Some(name),

range: (location..end_location).into()

},

))

}

},

}

OrPattern: ast::Pattern = {

<pattern:ClosedPattern> => pattern,

<location:@L> <patterns:TwoOrMore<ClosedPattern, "|">> <end_location:@R> => {

ast::Pattern::MatchOr(

ast::PatternMatchOr { patterns, range: (location..end_location).into() }

)

}

}

ClosedPattern: ast::Pattern = {

<node:LiteralPattern> => node,

<node:CapturePattern> => node,

<node:StarPattern> => node,

<node:ValuePattern> => node,

<node:SequencePattern> => node,

<node:MappingPattern> => node,

<node:ClassPattern> => node,

}

SequencePattern: ast::Pattern = {

// A single-item tuple is a special case: it's a group pattern, _not_ a sequence pattern.

<location:@L> "(" <pattern:Pattern> ")" <end_location:@R> => pattern,

<location:@L> "(" ")" <end_location:@R> => ast::PatternMatchSequence {

patterns: vec![],

range: (location..end_location).into()

}.into(),

<location:@L> "(" <pattern:Pattern> "," ")" <end_location:@R> => {

ast::PatternMatchSequence {

patterns: vec![pattern],

range: (location..end_location).into()

}.into()

},

<location:@L> "(" <patterns:(<Pattern> ",")+> <last:Pattern> ","? ")" <end_location:@R> => {

let mut patterns = patterns;

patterns.push(last);

ast::PatternMatchSequence {

patterns,

range: (location..end_location).into()

}.into()

},

<location:@L> "[" <patterns:Comma<Pattern>> "]" <end_location:@R> => ast::PatternMatchSequence {

patterns,

range: (location..end_location).into()

}.into(),

}

StarPattern: ast::Pattern = {

<location:@L> "*" <name:Identifier> <end_location:@R> => ast::PatternMatchStar {

name: if name.as_str() == "_" { None } else { Some(name) },

range: (location..end_location).into()

}.into(),

}

ConstantAtom: ast::Expr = {

<location:@L> <value:Constant> <end_location:@R> => ast::Expr::Constant(

ast::ExprConstant { value, kind: None, range: (location..end_location).into() }

),

}

ConstantExpr: ast::Expr = {

ConstantAtom,

<location:@L> "-" <operand:ConstantAtom> <end_location:@R> => ast::Expr::UnaryOp(

ast::ExprUnaryOp {

op: ast::Unaryop::USub,

operand: Box::new(operand),

range: (location..end_location).into()

}

),

}

AddOpExpr: ast::Expr = {

<location:@L> <left:ConstantExpr> <op:AddOp> <right:ConstantAtom> <end_location:@R> => ast::Expr::BinOp(

ast::ExprBinOp {

left: Box::new(left),

op,

right: Box::new(right),

range: (location..end_location).into()

}

),

}

LiteralPattern: ast::Pattern = {

<location:@L> "None" <end_location:@R> => ast::PatternMatchSingleton {

value: ast::Constant::None,

range: (location..end_location).into()

}.into(),

<location:@L> "True" <end_location:@R> => ast::PatternMatchSingleton {

value: true.into(),

range: (location..end_location).into()

}.into(),

<location:@L> "False" <end_location:@R> => ast::PatternMatchSingleton {

value: false.into(),

range: (location..end_location).into()

}.into(),

<location:@L> <value:ConstantExpr> <end_location:@R> => ast::PatternMatchValue {

value: Box::new(value),

range: (location..end_location).into()

}.into(),

<location:@L> <value:AddOpExpr> <end_location:@R> => ast::PatternMatchValue {

value: Box::new(value),

range: (location..end_location).into()

}.into(),

<location:@L> <s:(@L string @R)+> <end_location:@R> =>? Ok(ast::PatternMatchValue {

value: Box::new(parse_strings(s)?),

range: (location..end_location).into()

}.into()),

}

CapturePattern: ast::Pattern = {

<location:@L> <name:Identifier> <end_location:@R> => ast::PatternMatchAs {

pattern: None,

name: if name.as_str() == "_" { None } else { Some(name) },

range: (location..end_location).into()

}.into(),

}

MatchName: ast::Expr = {

<location:@L> <name:Identifier> <end_location:@R> => ast::Expr::Name(

ast::ExprName { id: name, ctx: ast::ExprContext::Load, range: (location..end_location).into() },

),

}

MatchNameOrAttr: ast::Expr = {

<location:@L> <name:MatchName> "." <attr:Identifier> <end_location:@R> => ast::Expr::Attribute(

ast::ExprAttribute {

value: Box::new(name),

attr,

ctx: ast::ExprContext::Load,

range: (location..end_location).into()

},

),

<location:@L> <e:MatchNameOrAttr> "." <attr:Identifier> <end_location:@R> => ast::Expr::Attribute(

ast::ExprAttribute {

value: Box::new(e),

attr,

ctx: ast::ExprContext::Load,

range: (location..end_location).into()

},

)

}

ValuePattern: ast::Pattern = {

<location:@L> <e:MatchNameOrAttr> <end_location:@R> => ast::PatternMatchValue {

value: Box::new(e),

range: (location..end_location).into()

}.into(),

}

MappingKey: ast::Expr = {

ConstantExpr,

AddOpExpr,

MatchNameOrAttr,

<location:@L> "None" <end_location:@R> => ast::Expr::Constant(

ast::ExprConstant {

value: ast::Constant::None,

kind: None,

range: (location..end_location).into()

},

),

<location:@L> "True" <end_location:@R> => ast::Expr::Constant(

ast::ExprConstant {

value: true.into(),

kind: None,

range: (location..end_location).into()

},

),

<location:@L> "False" <end_location:@R> => ast::Expr::Constant(

ast::ExprConstant {

value: false.into(),

kind: None,

range: (location..end_location).into()

},

),

<location:@L> <s:(@L string @R)+> =>? Ok(parse_strings(s)?),

}

MatchMappingEntry: (ast::Expr, ast::Pattern) = {

<k:MappingKey> ":" <v:Pattern> => (k, v),

};

MappingPattern: ast::Pattern = {

<location:@L> "{" "}" <end_location:@R> => {

return ast::PatternMatchMapping {

keys: vec![],

patterns: vec![],

rest: None,

range: (location..end_location).into()

}.into();

},

<location:@L> "{" <e:OneOrMore<MatchMappingEntry>> ","? "}" <end_location:@R> => {

let (keys, patterns) = e

.into_iter()

.unzip();

return ast::PatternMatchMapping {

keys,

patterns,

rest: None,

range: (location..end_location).into()

}.into();

},

<location:@L> "{" "**" <rest:Identifier> ","? "}" <end_location:@R> => {

return ast::PatternMatchMapping {

keys: vec![],

patterns: vec![],

rest: Some(rest),

range: (location..end_location).into()

}.into();

},

<location:@L> "{" <e:OneOrMore<MatchMappingEntry>> "," "**" <rest:Identifier> ","? "}" <end_location:@R> => {

let (keys, patterns) = e

.into_iter()

.unzip();

return ast::PatternMatchMapping {

keys,

patterns,

rest: Some(rest),

range: (location..end_location).into()

}.into();

},

}

MatchKeywordEntry: (ast::Identifier, ast::Pattern) = {

<k:Identifier> "=" <v:Pattern> => (k, v),

};

ClassPattern: ast::Pattern = {

<location:@L> <e:MatchName> "(" <patterns: OneOrMore<Pattern>> "," <kwds:OneOrMore<MatchKeywordEntry>> ","? ")" <end_location:@R> => {

let (kwd_attrs, kwd_patterns) = kwds

.into_iter()

.unzip();

ast::PatternMatchClass {

cls: Box::new(e),

patterns,

kwd_attrs,

kwd_patterns,

range: (location..end_location).into()

}.into()

},

<location:@L> <e:MatchName> "(" <patterns: OneOrMore<Pattern>> ","? ")" <end_location:@R> => {

ast::PatternMatchClass {

cls: Box::new(e),

patterns,

kwd_attrs: vec![],

kwd_patterns: vec![],

range: (location..end_location).into()

}.into()

},

<location:@L> <e:MatchName> "(" <kwds:OneOrMore<MatchKeywordEntry>> ","? ")" <end_location:@R> => {

let (kwd_attrs, kwd_patterns) = kwds

.into_iter()

.unzip();

ast::PatternMatchClass {

cls: Box::new(e),

patterns: vec![],

kwd_attrs,

kwd_patterns,

range: (location..end_location).into()

}.into()

},

<location:@L> <e:MatchName> "(" ")" <end_location:@R> => {

ast::PatternMatchClass {

cls: Box::new(e),

patterns: vec![],

kwd_attrs: vec![],

kwd_patterns: vec![],

range: (location..end_location).into()

}.into()

},

<location:@L> <e:MatchNameOrAttr> "(" <patterns: OneOrMore<Pattern>> "," <kwds:OneOrMore<MatchKeywordEntry>> ","? ")" <end_location:@R> => {

let (kwd_attrs, kwd_patterns) = kwds

.into_iter()

.unzip();

ast::PatternMatchClass {

cls: Box::new(e),

patterns,

kwd_attrs,

kwd_patterns,

range: (location..end_location).into()

}.into()

},

<location:@L> <e:MatchNameOrAttr> "(" <patterns: OneOrMore<Pattern>> ","? ")" <end_location:@R> => {

ast::PatternMatchClass {

cls: Box::new(e),

patterns,

kwd_attrs: vec![],

kwd_patterns: vec![],

range: (location..end_location).into()

}.into()

},

<location:@L> <e:MatchNameOrAttr> "(" <kwds:OneOrMore<MatchKeywordEntry>> ","? ")" <end_location:@R> => {

let (kwd_attrs, kwd_patterns) = kwds

.into_iter()

.unzip();

ast::PatternMatchClass {

cls: Box::new(e),

patterns: vec![],

kwd_attrs,

kwd_patterns,

range: (location..end_location).into()

}.into()

},

<location:@L> <e:MatchNameOrAttr> "(" ")" <end_location:@R> => {

ast::PatternMatchClass {

cls: Box::new(e),

patterns: vec![],

kwd_attrs: vec![],

kwd_patterns: vec![],

range: (location..end_location).into()

}.into()

},

}

IfStatement: ast::Stmt = {

<location:@L> "if" <test:NamedExpressionTest> ":" <body:Suite> <s2:(<@L> "elif" <NamedExpressionTest> ":" <Suite>)*> <s3:("else" ":" <Suite>)?> => {

// Determine last else:

let mut last = s3.unwrap_or_default();

let end_location = last

.last()

.or_else(|| s2.last().and_then(|last| last.2.last()))

.or_else(|| body.last())

.unwrap()

.end();

// handle elif:

for i in s2.into_iter().rev() {

let x = ast::Stmt::If(

ast::StmtIf { test: Box::new(i.1), body: i.2, orelse: last, range: (i.0..end_location).into() }

);

last = vec![x];

}

ast::Stmt::If(

ast::StmtIf { test: Box::new(test), body, orelse: last, range: (location..end_location).into() }

)

},

};

WhileStatement: ast::Stmt = {

<location:@L> "while" <test:NamedExpressionTest> ":" <body:Suite> <s2:("else" ":" <Suite>)?> => {

let orelse = s2.unwrap_or_default();

let end_location = orelse

.last()

.or_else(|| body.last())

.unwrap()

.end();

ast::Stmt::While(

ast::StmtWhile {

test: Box::new(test),

body,

orelse,

range: (location..end_location).into()

},

)

},

};

ForStatement: ast::Stmt = {

<location:@L> <is_async:"async"?> "for" <target:ExpressionList> "in" <iter:TestList> ":" <body:Suite> <orelse:("else" ":" <Suite>)?> => {

let orelse = orelse.unwrap_or_default();

let end_location = orelse

.last()

.or_else(|| body.last())

.unwrap()

.end();

let target = Box::new(set_context(target, ast::ExprContext::Store));

let iter = Box::new(iter);

let type_comment = None;

if is_async.is_some() {

ast::Stmt::AsyncFor(ast::StmtAsyncFor { target, iter, body, orelse, type_comment, range: (location..end_location).into() })

} else {

ast::Stmt::For(ast::StmtFor { target, iter, body, orelse, type_comment, range: (location..end_location).into() })

}

},

};

TryStatement: ast::Stmt = {

<location:@L> "try" ":" <body:Suite> <handlers:ExceptClause+> <orelse:("else" ":" <Suite>)?> <finalbody:("finally" ":" <Suite>)?> <end_location:@R> => {

let orelse = orelse.unwrap_or_default();

let finalbody = finalbody.unwrap_or_default();

let end_location = finalbody

.last()

.map(|last| last.end())

.or_else(|| orelse.last().map(|last| last.end()))

.or_else(|| handlers.last().map(|last| last.end()))

.unwrap();

ast::Stmt::Try(

ast::StmtTry {

body,

handlers,

orelse,

finalbody,

range: (location..end_location).into()

},

)

},

<location:@L> "try" ":" <body:Suite> <handlers:ExceptStarClause+> <orelse:("else" ":" <Suite>)?> <finalbody:("finally" ":" <Suite>)?> <end_location:@R> => {

let orelse = orelse.unwrap_or_default();

let finalbody = finalbody.unwrap_or_default();

let end_location = finalbody

.last()

.or_else(|| orelse.last())

.map(|last| last.end())

.or_else(|| handlers.last().map(|last| last.end()))

.unwrap();

ast::Stmt::TryStar(

ast::StmtTryStar {

body,

handlers,

orelse,

finalbody,

range: (location..end_location).into()

},

)

},

<location:@L> "try" ":" <body:Suite> <finalbody:("finally" ":" <Suite>)> => {

let handlers = vec![];

let orelse = vec![];

let end_location = finalbody.last().unwrap().end();

ast::Stmt::Try(

ast::StmtTry {

body,

handlers,

orelse,

finalbody,

range: (location..end_location).into()

},

)

},

};

ExceptStarClause: ast::Excepthandler = {

<location:@L> "except" "*" <typ:Test<"all">> ":" <body:Suite> => {

let end_location = body.last().unwrap().end();

ast::Excepthandler::ExceptHandler(

ast::ExcepthandlerExceptHandler {

type_: Some(Box::new(typ)),

name: None,

body,

range: (location..end_location).into()

},

)

},

<location:@L> "except" "*" <x:(<Test<"all">> "as" <Identifier>)> ":" <body:Suite> => {

let end_location = body.last().unwrap().end();

ast::Excepthandler::ExceptHandler(

ast::ExcepthandlerExceptHandler {

type_: Some(Box::new(x.0)),

name: Some(x.1),

body,

range: (location..end_location).into()

},

)

},

};

ExceptClause: ast::Excepthandler = {

<location:@L> "except" <typ:Test<"all">?> ":" <body:Suite> => {

let end_location = body.last().unwrap().end();

ast::Excepthandler::ExceptHandler(

ast::ExcepthandlerExceptHandler {

type_: typ.map(Box::new),

name: None,

body,

range: (location..end_location).into()

},

)

},

<location:@L> "except" <x:(<Test<"all">> "as" <Identifier>)> ":" <body:Suite> => {

let end_location = body.last().unwrap().end();

ast::Excepthandler::ExceptHandler(

ast::ExcepthandlerExceptHandler {

type_: Some(Box::new(x.0)),

name: Some(x.1),

body,

range: (location..end_location).into()

},

)

},

};

WithStatement: ast::Stmt = {

<location:@L> <is_async:"async"?> "with" <items:WithItems> ":" <body:Suite> => {

let end_location = body.last().unwrap().end();

let type_comment = None;

if is_async.is_some() {

ast::StmtAsyncWith { items, body, type_comment, range: (location..end_location).into() }.into()

} else {

ast::StmtWith { items, body, type_comment, range: (location..end_location).into() }.into()

}

},

};

WithItems: Vec<ast::Withitem> = {

"(" <WithItemsNoAs> ","? ")",

"(" <left:(<WithItemsNoAs> ",")?> <mid:WithItem<"as">> <right:("," <WithItem<"all">>)*> ","? ")" => {

left.into_iter().flatten().chain([mid]).chain(right).collect()

},

<WithItem<"no-withitems">> => vec![<>],

<item:WithItem<"all">> <items:("," <WithItem<"all">>)+> => {

[item].into_iter().chain(items).collect()

}

};

#[inline]

WithItemsNoAs: Vec<ast::Withitem> = {

<location:@L> <all:OneOrMore<Test<"all">>> <end_location:@R> => {

all.into_iter().map(|context_expr| ast::Withitem { context_expr, optional_vars: None, range: optional_range(location, end_location) }).collect()

},

}

WithItem<Goal>: ast::Withitem = {

<location:@L> <context_expr: Test<Goal>> <end_location:@R> if Goal != "as" => ast::Withitem { context_expr, optional_vars: None, range: optional_range(location, end_location) },

<location:@L> <context_expr:Test<"all">> "as" <vars:Expression<"all">> <end_location:@R> => {

let optional_vars = Some(Box::new(set_context(vars, ast::ExprContext::Store)));

ast::Withitem { context_expr, optional_vars, range: optional_range(location, end_location) }

},

};

FuncDef: ast::Stmt = {

<decorator_list:Decorator*> <location:@L> <is_async:"async"?> "def" <name:Identifier> <args:Parameters> <r:("->" <Test<"all">>)?> ":" <body:Suite> => {

let args = Box::new(args);

let returns = r.map(|x| Box::new(x));

let end_location = body.last().unwrap().end();

let type_comment = None;

if is_async.is_some() {

ast::StmtAsyncFunctionDef { name, args, body, decorator_list, returns, type_comment, range: (location..end_location).into() }.into()

} else {

ast::StmtFunctionDef { name, args, body, decorator_list, returns, type_comment, range: (location..end_location).into() }.into()

}

},

};

Parameters: ast::Arguments = {

<location:@L> "(" <a: (ParameterList<TypedParameter, StarTypedParameter>)?> ")" <end_location:@R> =>? {

let args = a.map(validate_arguments).transpose()?.unwrap_or_else(|| ast::Arguments {

posonlyargs: vec![],

args: vec![],

vararg: None,

kwonlyargs: vec![],

kw_defaults: vec![],

kwarg: None,

defaults: vec![],

range: optional_range(location, end_location)

});

Ok(args)

}

};

// Note that this is a macro which is used once for function defs, and

// once for lambda defs.

ParameterList<ArgType, StarArgType>: ast::Arguments = {

<location:@L> <param1:ParameterDefs<ArgType>> <args2:("," <ParameterListStarArgs<ArgType, StarArgType>>)?> ","? <end_location:@R> =>? {