mirrors/RustPython-Parser
1
0
Fork 0
mirror of https://github.com/RustPython/Parser.git synced 2025-07-08 05:35:22 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

FunctionArguments and ArgWithDefault as raw AST representation

Browse source
This commit is contained in:
Jeong YunWon 2023-05-19 00:12:31 +09:00
parent 3fbf4f6804
commit b4d0eafd3e
48 changed files with 28473 additions and 22643 deletions
Download patch file Download diff file Expand all files Collapse all files

12
ast-pyo3/src/py_ast.rs
View file

@ -78,6 +78,18 @@ impl ToPyAst for ConversionFlag {
}
}
impl<R> ToPyAst for ast::FunctionArguments<R>
where
Self: Clone,
ast::Arguments<R>: ToPyAst,
{
#[inline]
fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
let arguments = ast::Arguments::from(self.clone());
arguments.to_py_ast(py)
}
}
fn constant_to_object(constant: &ast::Constant, py: Python) -> PyObject {
let cache = ast_cache();
match constant {

13
ast-pyo3/src/wrapper.rs
View file

@ -94,6 +94,19 @@ impl<T: ToPyWrapper> ToPyWrapper for Vec<T> {
}
#[pyclass(module = "rustpython_ast", name = "AST", subclass)]
impl<R> ToPyWrapper for ast::FunctionArguments<R>
where
Self: Clone,
ast::Arguments<R>: ToPyWrapper,
{
#[inline]
fn to_py_wrapper(&'static self, _py: Python) -> PyResult<Py<PyAny>> {
todo!()
// Ok(FunctionArguments(self).to_object(py))
}
}
#[pyclass(module = "rustpython_ast", subclass)]
pub struct Ast;
#[pymethods]

190
ast/asdl_rs.py
View file

@ -45,6 +45,67 @@ RUST_KEYWORDS = {
"type",
}
attributes = [
asdl.Field("int", "lineno"),
asdl.Field("int", "col_offset"),
asdl.Field("int", "end_lineno"),
asdl.Field("int", "end_col_offset"),
]
ORIGINAL_NODE_WARNING = "NOTE: This type is different from original Python AST."
arg_with_default = asdl.Type(
"arg_with_default",
asdl.Product(
[
asdl.Field("arg", "def"),
asdl.Field("expr", "default", opt=True), # order is important for cost-free borrow!
],
),
)
arg_with_default.doc = f"""
An alternative type of AST `arg`. This is used for function arguments *with* default value.
Used by `FunctionArguments` original type.
{ORIGINAL_NODE_WARNING}
""".strip()
function_arguments = asdl.Type(
"function_arguments",
asdl.Product(
[
asdl.Field("arg_with_default", "posonlyargs", seq=True),
asdl.Field("arg_with_default", "args", seq=True),
asdl.Field("arg", "vararg", opt=True),
asdl.Field("arg_with_default", "kwonlyargs", seq=True),
asdl.Field("arg", "kwarg", opt=True),
]
),
)
function_arguments.doc = f"""
An alternative type of AST `arguments`. This is parser-friendly definition of function arguments.
`defaults` and `kw_defaults` are placed under each `arg_with_default` typed fields.
{ORIGINAL_NODE_WARNING}
""".strip()
# Must be used only for rust types, not python types
CUSTOM_TYPES = [
function_arguments,
arg_with_default,
]
CUSTOM_REPLACEMENTS = {
"arguments": function_arguments,
}
CUSTOM_ATTACHMENTS = [
arg_with_default,
]
def maybe_custom(type):
return CUSTOM_REPLACEMENTS.get(type.name, type)
def rust_field_name(name):
name = rust_type_name(name)
@ -137,6 +198,10 @@ class TypeInfo:
f.type != "identifier" for f in self.type.value.fields
)
@property
def is_custom(self):
return self.type.name in [t.name for t in CUSTOM_TYPES]
def no_cfg(self, typeinfo):
if self.is_product:
return self.has_attributes
@ -150,14 +215,14 @@ class TypeInfo:
return rust_type_name(self.name)
@property
def sum_name(self):
def full_field_name(self):
if self.enum_name is None:
return self.name
else:
return f"{self.enum_name}_{self.name}"
return f"{self.enum_name}_{rust_field_name(self.name)}"
@property
def rust_sum_name(self):
def full_type_name(self):
rust_name = rust_type_name(self.name)
if self.enum_name is None:
return rust_name
@ -223,7 +288,7 @@ class FindUserDataTypesVisitor(asdl.VisitorBase):
super().__init__()
def visitModule(self, mod):
for dfn in mod.dfns:
for dfn in mod.dfns + CUSTOM_TYPES:
self.visit(dfn)
stack = set()
for info in self.type_info.values():
@ -308,6 +373,7 @@ class StructVisitor(EmitVisitor):
0,
)
for dfn in mod.dfns:
dfn = maybe_custom(dfn)
rust_name = rust_type_name(dfn.name)
generics = "" if self.type_info[dfn.name].is_simple else "<R>"
if dfn.name == "mod":
@ -329,6 +395,7 @@ class StructVisitor(EmitVisitor):
0,
)
for dfn in mod.dfns:
dfn = maybe_custom(dfn)
rust_name = rust_type_name(dfn.name)
generics = "" if self.type_info[dfn.name].is_simple else "<R>"
self.emit(
@ -342,10 +409,13 @@ class StructVisitor(EmitVisitor):
0,
)
for dfn in mod.dfns:
for dfn in mod.dfns + CUSTOM_TYPES:
self.visit(dfn)
def visitType(self, type, depth=0):
if hasattr(type, "doc"):
doc = "/// " + type.doc.replace("\n", "\n/// ") + "\n"
self.emit(doc, depth)
self.visit(type.value, type, depth)
def visitSum(self, sum, type, depth):
@ -492,8 +562,12 @@ class StructVisitor(EmitVisitor):
self.emit(f"{cons.name},", depth)
def visitField(self, field, parent, vis, depth, constructor=None):
typ = rust_type_name(field.type)
field_type = self.type_info.get(field.type)
if field.type in CUSTOM_REPLACEMENTS:
type_name = CUSTOM_REPLACEMENTS[field.type].name
else:
type_name = field.type
typ = rust_type_name(type_name)
field_type = self.type_info.get(type_name)
if field_type and not field_type.is_simple:
typ = f"{typ}<R>"
# don't box if we're doing Vec<T>, but do box if we're doing Vec<Option<Box<T>>>
@ -522,7 +596,6 @@ class StructVisitor(EmitVisitor):
type_info = self.type_info[type.name]
product_name = rust_type_name(type.name)
self.emit_attrs(depth)
self.emit(f"pub struct {product_name}<R = TextRange> {{", depth)
self.emit_range(product.attributes, depth + 1)
for f in product.fields:
@ -584,7 +657,8 @@ class FoldTraitDefVisitor(EmitVisitor):
}""",
depth + 1,
)
for dfn in mod.dfns:
for dfn in mod.dfns + [arg_with_default]:
dfn = maybe_custom(dfn)
self.visit(dfn, depth + 2)
self.emit("}", depth)
@ -617,7 +691,8 @@ class FoldTraitDefVisitor(EmitVisitor):
class FoldImplVisitor(EmitVisitor):
def visitModule(self, mod, depth):
for dfn in mod.dfns:
for dfn in mod.dfns + [arg_with_default]:
dfn = maybe_custom(dfn)
self.visit(dfn, depth)
def visitType(self, type, depth=0):
@ -777,7 +852,7 @@ class FoldModuleVisitor(EmitVisitor):
FoldImplVisitor(self.file, self.type_info).visit(mod, depth)
class VisitorTraitDefVisitor(StructVisitor):
class VisitorModuleVisitor(StructVisitor):
def full_name(self, name):
type_info = self.type_info[name]
if type_info.enum_name:
@ -792,10 +867,11 @@ class VisitorTraitDefVisitor(StructVisitor):
else:
return rust_type_name(name)
def visitModule(self, mod, depth):
def visitModule(self, mod, depth=0):
self.emit("#[allow(unused_variables)]", depth)
self.emit("pub trait Visitor<R=crate::text_size::TextRange> {", depth)
for dfn in mod.dfns:
for dfn in mod.dfns + CUSTOM_TYPES:
self.visit(dfn, depth + 1)
self.emit("}", depth)
@ -810,26 +886,28 @@ class VisitorTraitDefVisitor(StructVisitor):
def emit_visitor(self, nodename, depth, has_node=True):
type_info = self.type_info[nodename]
node_type = type_info.rust_sum_name
node_type = type_info.full_type_name
(generic,) = self.apply_generics(nodename, "R")
self.emit(
f"fn visit_{type_info.sum_name}(&mut self, node: {node_type}{generic}) {{",
f"fn visit_{type_info.full_field_name}(&mut self, node: {node_type}{generic}) {{",
depth,
)
if has_node:
self.emit(f"self.generic_visit_{type_info.sum_name}(node)", depth + 1)
self.emit(
f"self.generic_visit_{type_info.full_field_name}(node)", depth + 1
)
self.emit("}", depth)
def emit_generic_visitor_signature(self, nodename, depth, has_node=True):
type_info = self.type_info[nodename]
if has_node:
node_type = type_info.rust_sum_name
node_type = type_info.full_type_name
else:
node_type = "()"
(generic,) = self.apply_generics(nodename, "R")
self.emit(
f"fn generic_visit_{type_info.sum_name}(&mut self, node: {node_type}{generic}) {{",
f"fn generic_visit_{type_info.full_field_name}(&mut self, node: {node_type}{generic}) {{",
depth,
)
@ -844,7 +922,9 @@ class VisitorTraitDefVisitor(StructVisitor):
def visit_match_for_type(self, nodename, rust_name, type_, depth):
self.emit(f"{rust_name}::{type_.name}", depth)
self.emit("(data)", depth)
self.emit(f"=> self.visit_{nodename}_{type_.name}(data),", depth)
self.emit(
f"=> self.visit_{nodename}_{rust_field_name(type_.name)}(data),", depth
)
def visit_sum_type(self, name, type_, depth):
self.emit_visitor(type_.name, depth, has_node=type_.fields)
@ -852,28 +932,32 @@ class VisitorTraitDefVisitor(StructVisitor):
return
self.emit_generic_visitor_signature(type_.name, depth, has_node=True)
for f in type_.fields:
fieldname = rust_field(f.name)
field_type = self.type_info.get(f.type)
for field in type_.fields:
if field.type in CUSTOM_REPLACEMENTS:
type_name = CUSTOM_REPLACEMENTS[field.type].name
else:
type_name = field.type
field_name = rust_field(field.name)
field_type = self.type_info.get(type_name)
if not (field_type and field_type.has_user_data):
continue
if f.opt:
self.emit(f"if let Some(value) = node.{fieldname} {{", depth + 1)
elif f.seq:
iterable = f"node.{fieldname}"
if type_.name == "Dict" and f.name == "keys":
if field.opt:
self.emit(f"if let Some(value) = node.{field_name} {{", depth + 1)
elif field.seq:
iterable = f"node.{field_name}"
if type_.name == "Dict" and field.name == "keys":
iterable = f"{iterable}.into_iter().flatten()"
self.emit(f"for value in {iterable} {{", depth + 1)
else:
self.emit("{", depth + 1)
self.emit(f"let value = node.{fieldname};", depth + 2)
self.emit(f"let value = node.{field_name};", depth + 2)
variable = "value"
if field_type.boxed and (not f.seq or f.opt):
if field_type.boxed and (not field.seq or field.opt):
variable = "*" + variable
type_info = self.type_info[field_type.name]
self.emit(f"self.visit_{type_info.sum_name}({variable});", depth + 2)
self.emit(f"self.visit_{type_info.full_field_name}({variable});", depth + 2)
self.emit("}", depth + 1)
@ -903,16 +987,9 @@ class VisitorTraitDefVisitor(StructVisitor):
self.emit_empty_generic_visitor(name, depth)
class VisitorModuleVisitor(EmitVisitor):
def visitModule(self, mod):
depth = 0
self.emit("#[allow(unused_variables, non_snake_case)]", depth)
VisitorTraitDefVisitor(self.file, self.type_info).visit(mod, depth)
class RangedDefVisitor(EmitVisitor):
def visitModule(self, mod):
for dfn in mod.dfns:
for dfn in mod.dfns + CUSTOM_TYPES:
self.visit(dfn)
def visitType(self, type, depth=0):
@ -944,7 +1021,7 @@ class RangedDefVisitor(EmitVisitor):
self.emit(
f"""
impl Ranged for crate::{info.rust_sum_name} {{
impl Ranged for crate::{info.full_type_name} {{
fn range(&self) -> TextRange {{
match self {{
{sum_match_arms}
@ -966,7 +1043,7 @@ class RangedDefVisitor(EmitVisitor):
generics = "" if info.is_simple else "::<TextRange>"
self.emit(
f"pub type {info.rust_sum_name} = crate::generic::{info.rust_sum_name}{generics};",
f"pub type {info.full_type_name} = crate::generic::{info.full_type_name}{generics};",
0,
)
self.emit("", 0)
@ -977,7 +1054,7 @@ class RangedDefVisitor(EmitVisitor):
self.file.write(
f"""
impl Ranged for crate::generic::{info.rust_sum_name}::<TextRange> {{
impl Ranged for crate::generic::{info.full_type_name}::<TextRange> {{
fn range(&self) -> TextRange {{
self.range
}}
@ -988,7 +1065,7 @@ class RangedDefVisitor(EmitVisitor):
class LocatedDefVisitor(EmitVisitor):
def visitModule(self, mod):
for dfn in mod.dfns:
for dfn in mod.dfns + CUSTOM_TYPES:
self.visit(dfn)
def visitType(self, type, depth=0):
@ -1020,7 +1097,7 @@ class LocatedDefVisitor(EmitVisitor):
self.emit(
f"""
impl Located for {info.rust_sum_name} {{
impl Located for {info.full_type_name} {{
fn range(&self) -> SourceRange {{
match self {{
{sum_match_arms}
@ -1041,7 +1118,7 @@ class LocatedDefVisitor(EmitVisitor):
generics = "" if info.is_simple else "::<SourceRange>"
self.emit(
f"pub type {info.rust_sum_name} = crate::generic::{info.rust_sum_name}{generics};",
f"pub type {info.full_type_name} = crate::generic::{info.full_type_name}{generics};",
0,
)
self.emit("", 0)
@ -1052,7 +1129,7 @@ class LocatedDefVisitor(EmitVisitor):
self.emit(
f"""
impl Located for {info.rust_sum_name} {{
impl Located for {info.full_type_name} {{
fn range(&self) -> SourceRange {{
self.range
}}
@ -1598,9 +1675,6 @@ class StdlibTraitImplVisitor(EmitVisitor):
def visitSum(self, sum, name, depth):
rust_name = rust_type_name(name)
self.emit(f"impl NamedNode for ast::located::{rust_name} {{", depth)
self.emit(f"const NAME: &'static str = {json.dumps(name)};", depth + 1)
self.emit("}", depth)
self.emit("// sum", depth)
self.emit(f"impl Node for ast::located::{rust_name} {{", depth)
self.emit(
@ -1644,11 +1718,6 @@ class StdlibTraitImplVisitor(EmitVisitor):
def visitConstructor(self, cons, sum, sum_rust_name, depth):
rust_name = rust_type_name(cons.name)
self.emit("// constructor", depth)
self.emit(
f"impl NamedNode for ast::located::{sum_rust_name}{rust_name} {{", depth
)
self.emit(f"const NAME: &'static str = {json.dumps(cons.name)};", depth + 1)
self.emit("}", depth)
self.emit(f"impl Node for ast::located::{sum_rust_name}{rust_name} {{", depth)
fields_pattern = self.make_pattern(cons.fields)
@ -1680,9 +1749,6 @@ class StdlibTraitImplVisitor(EmitVisitor):
struct_name = rust_type_name(name)
self.emit("// product", depth)
self.emit(f"impl NamedNode for ast::located::{struct_name} {{", depth)
self.emit(f"const NAME: &'static str = {json.dumps(name)};", depth + 1)
self.emit("}", depth)
self.emit(f"impl Node for ast::located::{struct_name} {{", depth)
self.emit(
"fn ast_to_object(self, _vm: &VirtualMachine) -> PyObjectRef {", depth + 1
@ -1827,7 +1893,7 @@ def write_located_def(mod, type_info, f):
def write_pyo3_node(type_info, f):
def write(info: TypeInfo):
rust_name = info.rust_sum_name
rust_name = info.full_type_name
if info.is_simple:
generics = ""
else:
@ -1846,6 +1912,8 @@ def write_pyo3_node(type_info, f):
)
for info in type_info.values():
if info.is_custom:
continue
write(info)
@ -1864,7 +1932,9 @@ def write_to_pyo3(mod, type_info, f):
)
for info in type_info.values():
rust_name = info.rust_sum_name
if info.is_custom:
continue
rust_name = info.full_type_name
f.write(f"cache_py_type::<ast::{rust_name}>(ast_module)?;\n")
f.write("Ok(())\n}")
@ -1876,7 +1946,7 @@ def write_to_pyo3_simple(type_info, f):
if not type_info.is_simple:
continue
rust_name = type_info.rust_sum_name
rust_name = type_info.full_type_name
f.write(
f"""
impl ToPyAst for ast::{rust_name} {{
@ -1907,7 +1977,7 @@ def write_pyo3_wrapper(mod, type_info, namespace, f):
if not type_info.is_simple or not type_info.is_sum:
continue
rust_name = type_info.rust_sum_name
rust_name = type_info.full_type_name
f.write(
f"""
impl ToPyWrapper for ast::{rust_name} {{

64
ast/src/gen/fold.rs
View file

@ -420,11 +420,11 @@ pub trait Fold<U> {
) -> Result<ExcepthandlerExceptHandler<Self::TargetU>, Self::Error> {
fold_excepthandler_except_handler(self, node)
}
fn fold_arguments(
fn fold_function_arguments(
&mut self,
node: Arguments<U>,
) -> Result<Arguments<Self::TargetU>, Self::Error> {
fold_arguments(self, node)
node: FunctionArguments<U>,
) -> Result<FunctionArguments<Self::TargetU>, Self::Error> {
fold_function_arguments(self, node)
}
fn fold_arg(&mut self, node: Arg<U>) -> Result<Arg<Self::TargetU>, Self::Error> {
fold_arg(self, node)
@ -507,6 +507,12 @@ pub trait Fold<U> {
) -> Result<TypeIgnoreTypeIgnore<Self::TargetU>, Self::Error> {
fold_type_ignore_type_ignore(self, node)
}
fn fold_arg_with_default(
&mut self,
node: ArgWithDefault<U>,
) -> Result<ArgWithDefault<Self::TargetU>, Self::Error> {
fold_arg_with_default(self, node)
}
}
impl<T, U> Foldable<T, U> for Mod<T> {
type Mapped = Mod<U>;
@ -2350,27 +2356,25 @@ pub fn fold_excepthandler_except_handler<U, F: Fold<U> + ?Sized>(
range,
})
}
impl<T, U> Foldable<T, U> for Arguments<T> {
type Mapped = Arguments<U>;
impl<T, U> Foldable<T, U> for FunctionArguments<T> {
type Mapped = FunctionArguments<U>;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_arguments(self)
folder.fold_function_arguments(self)
}
}
pub fn fold_arguments<U, F: Fold<U> + ?Sized>(
pub fn fold_function_arguments<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Arguments<U>,
) -> Result<Arguments<F::TargetU>, F::Error> {
let Arguments {
node: FunctionArguments<U>,
) -> Result<FunctionArguments<F::TargetU>, F::Error> {
let FunctionArguments {
posonlyargs,
args,
vararg,
kwonlyargs,
kw_defaults,
kwarg,
defaults,
range,
} = node;
let context = folder.will_map_user_cfg(&range);
@ -2378,18 +2382,14 @@ pub fn fold_arguments<U, F: Fold<U> + ?Sized>(
let args = Foldable::fold(args, folder)?;
let vararg = Foldable::fold(vararg, folder)?;
let kwonlyargs = Foldable::fold(kwonlyargs, folder)?;
let kw_defaults = Foldable::fold(kw_defaults, folder)?;
let kwarg = Foldable::fold(kwarg, folder)?;
let defaults = Foldable::fold(defaults, folder)?;
let range = folder.map_user_cfg(range, context)?;
Ok(Arguments {
Ok(FunctionArguments {
posonlyargs,
args,
vararg,
kwonlyargs,
kw_defaults,
kwarg,
defaults,
range,
})
}
@ -2791,3 +2791,31 @@ pub fn fold_type_ignore_type_ignore<U, F: Fold<U> + ?Sized>(
let range = folder.map_user_cfg(range, context)?;
Ok(TypeIgnoreTypeIgnore { lineno, tag, range })
}
impl<T, U> Foldable<T, U> for ArgWithDefault<T> {
type Mapped = ArgWithDefault<U>;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_arg_with_default(self)
}
}
pub fn fold_arg_with_default<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: ArgWithDefault<U>,
) -> Result<ArgWithDefault<F::TargetU>, F::Error> {
let ArgWithDefault {
def,
default,
range,
} = node;
let context = folder.will_map_user_cfg(&range);
let def = Foldable::fold(def, folder)?;
let default = Foldable::fold(default, folder)?;
let range = folder.map_user_cfg(range, context)?;
Ok(ArgWithDefault {
def,
default,
range,
})
}

52
ast/src/gen/generic.rs
View file

@ -15,7 +15,7 @@ pub enum Ast<R = TextRange> {
Cmpop(Cmpop),
Comprehension(Comprehension<R>),
Excepthandler(Excepthandler<R>),
Arguments(Arguments<R>),
FunctionArguments(FunctionArguments<R>),
Arg(Arg<R>),
Keyword(Keyword<R>),
Alias(Alias<R>),
@ -89,9 +89,9 @@ impl<R> From<Excepthandler<R>> for Ast<R> {
}
}
impl<R> From<Arguments<R>> for Ast<R> {
fn from(node: Arguments<R>) -> Self {
Ast::Arguments(node)
impl<R> From<FunctionArguments<R>> for Ast<R> {
fn from(node: FunctionArguments<R>) -> Self {
Ast::FunctionArguments(node)
}
}
@ -240,7 +240,7 @@ impl<R> Node for Mod<R> {
pub struct StmtFunctionDef<R = TextRange> {
pub range: R,
pub name: Identifier,
pub args: Box<Arguments<R>>,
pub args: Box<FunctionArguments<R>>,
pub body: Vec<Stmt<R>>,
pub decorator_list: Vec<Expr<R>>,
pub returns: Option<Box<Expr<R>>>,
@ -273,7 +273,7 @@ impl<R> From<StmtFunctionDef<R>> for Ast<R> {
pub struct StmtAsyncFunctionDef<R = TextRange> {
pub range: R,
pub name: Identifier,
pub args: Box<Arguments<R>>,
pub args: Box<FunctionArguments<R>>,
pub body: Vec<Stmt<R>>,
pub decorator_list: Vec<Expr<R>>,
pub returns: Option<Box<Expr<R>>>,
@ -1020,7 +1020,7 @@ impl<R> From<ExprUnaryOp<R>> for Ast<R> {
#[derive(Clone, Debug, PartialEq)]
pub struct ExprLambda<R = TextRange> {
pub range: R,
pub args: Box<Arguments<R>>,
pub args: Box<FunctionArguments<R>>,
pub body: Box<Expr<R>>,
}
@ -2987,3 +2987,41 @@ impl<R> Node for TypeIgnore<R> {
const NAME: &'static str = "type_ignore";
const FIELD_NAMES: &'static [&'static str] = &[];
}
/// An alternative type of AST `arguments`. This is parser-friendly definition of function arguments.
/// `defaults` and `kw_defaults` are placed under each `arg_with_default` typed fields.
///
/// NOTE: This type is different from original Python AST.
#[derive(Clone, Debug, PartialEq)]
pub struct FunctionArguments<R = TextRange> {
pub range: OptionalRange<R>,
pub posonlyargs: Vec<ArgWithDefault<R>>,
pub args: Vec<ArgWithDefault<R>>,
pub vararg: Option<Box<Arg<R>>>,
pub kwonlyargs: Vec<ArgWithDefault<R>>,
pub kwarg: Option<Box<Arg<R>>>,
}
impl<R> Node for FunctionArguments<R> {
const NAME: &'static str = "function_arguments";
const FIELD_NAMES: &'static [&'static str] =
&["posonlyargs", "args", "vararg", "kwonlyargs", "kwarg"];
}
/// An alternative type of AST `arg`. This is used for function arguments *with* default value.
/// Used by `FunctionArguments` original type.
///
/// NOTE: This type is different from original Python AST.
#[derive(Clone, Debug, PartialEq)]
pub struct ArgWithDefault<R = TextRange> {
pub range: OptionalRange<R>,
pub def: Arg<R>,
pub default: Option<Box<Expr<R>>>,
}
impl<R> Node for ArgWithDefault<R> {
const NAME: &'static str = "arg_with_default";
const FIELD_NAMES: &'static [&'static str] = &["def", "default"];
}

20
ast/src/gen/located.rs
View file

@ -815,3 +815,23 @@ impl Located for TypeIgnore {
}
}
}
pub type FunctionArguments = crate::generic::FunctionArguments<SourceRange>;
#[cfg(feature = "all-nodes-with-ranges")]
impl Located for FunctionArguments {
fn range(&self) -> SourceRange {
self.range
}
}
pub type ArgWithDefault = crate::generic::ArgWithDefault<SourceRange>;
#[cfg(feature = "all-nodes-with-ranges")]
impl Located for ArgWithDefault {
fn range(&self) -> SourceRange {
self.range
}
}

13
ast/src/gen/ranged.rs
View file

@ -495,3 +495,16 @@ impl Ranged for crate::TypeIgnore {
}
}
}
#[cfg(feature = "all-nodes-with-ranges")]
impl Ranged for crate::generic::FunctionArguments<TextRange> {
fn range(&self) -> TextRange {
self.range
}
}
#[cfg(feature = "all-nodes-with-ranges")]
impl Ranged for crate::generic::ArgWithDefault<TextRange> {
fn range(&self) -> TextRange {
self.range
}
}

4953
ast/src/gen/to_pyo3.rs Normal file
View file

File diff suppressed because it is too large Load diff

508
ast/src/gen/visitor.rs
View file

@ -1,48 +1,48 @@
// File automatically generated by ast/asdl_rs.py.
#[allow(unused_variables, non_snake_case)]
#[allow(unused_variables)]
pub trait Visitor<R = crate::text_size::TextRange> {
fn visit_stmt(&mut self, node: Stmt<R>) {
self.generic_visit_stmt(node)
}
fn generic_visit_stmt(&mut self, node: Stmt<R>) {
match node {
Stmt::FunctionDef(data) => self.visit_stmt_FunctionDef(data),
Stmt::AsyncFunctionDef(data) => self.visit_stmt_AsyncFunctionDef(data),
Stmt::ClassDef(data) => self.visit_stmt_ClassDef(data),
Stmt::Return(data) => self.visit_stmt_Return(data),
Stmt::Delete(data) => self.visit_stmt_Delete(data),
Stmt::Assign(data) => self.visit_stmt_Assign(data),
Stmt::AugAssign(data) => self.visit_stmt_AugAssign(data),
Stmt::AnnAssign(data) => self.visit_stmt_AnnAssign(data),
Stmt::For(data) => self.visit_stmt_For(data),
Stmt::AsyncFor(data) => self.visit_stmt_AsyncFor(data),
Stmt::While(data) => self.visit_stmt_While(data),
Stmt::If(data) => self.visit_stmt_If(data),
Stmt::With(data) => self.visit_stmt_With(data),
Stmt::AsyncWith(data) => self.visit_stmt_AsyncWith(data),
Stmt::Match(data) => self.visit_stmt_Match(data),
Stmt::Raise(data) => self.visit_stmt_Raise(data),
Stmt::Try(data) => self.visit_stmt_Try(data),
Stmt::TryStar(data) => self.visit_stmt_TryStar(data),
Stmt::Assert(data) => self.visit_stmt_Assert(data),
Stmt::Import(data) => self.visit_stmt_Import(data),
Stmt::ImportFrom(data) => self.visit_stmt_ImportFrom(data),
Stmt::Global(data) => self.visit_stmt_Global(data),
Stmt::Nonlocal(data) => self.visit_stmt_Nonlocal(data),
Stmt::Expr(data) => self.visit_stmt_Expr(data),
Stmt::Pass(data) => self.visit_stmt_Pass(data),
Stmt::Break(data) => self.visit_stmt_Break(data),
Stmt::Continue(data) => self.visit_stmt_Continue(data),
Stmt::FunctionDef(data) => self.visit_stmt_function_def(data),
Stmt::AsyncFunctionDef(data) => self.visit_stmt_async_function_def(data),
Stmt::ClassDef(data) => self.visit_stmt_class_def(data),
Stmt::Return(data) => self.visit_stmt_return(data),
Stmt::Delete(data) => self.visit_stmt_delete(data),
Stmt::Assign(data) => self.visit_stmt_assign(data),
Stmt::AugAssign(data) => self.visit_stmt_aug_assign(data),
Stmt::AnnAssign(data) => self.visit_stmt_ann_assign(data),
Stmt::For(data) => self.visit_stmt_for(data),
Stmt::AsyncFor(data) => self.visit_stmt_async_for(data),
Stmt::While(data) => self.visit_stmt_while(data),
Stmt::If(data) => self.visit_stmt_if(data),
Stmt::With(data) => self.visit_stmt_with(data),
Stmt::AsyncWith(data) => self.visit_stmt_async_with(data),
Stmt::Match(data) => self.visit_stmt_match(data),
Stmt::Raise(data) => self.visit_stmt_raise(data),
Stmt::Try(data) => self.visit_stmt_try(data),
Stmt::TryStar(data) => self.visit_stmt_try_star(data),
Stmt::Assert(data) => self.visit_stmt_assert(data),
Stmt::Import(data) => self.visit_stmt_import(data),
Stmt::ImportFrom(data) => self.visit_stmt_import_from(data),
Stmt::Global(data) => self.visit_stmt_global(data),
Stmt::Nonlocal(data) => self.visit_stmt_nonlocal(data),
Stmt::Expr(data) => self.visit_stmt_expr(data),
Stmt::Pass(data) => self.visit_stmt_pass(data),
Stmt::Break(data) => self.visit_stmt_break(data),
Stmt::Continue(data) => self.visit_stmt_continue(data),
}
}
fn visit_stmt_FunctionDef(&mut self, node: StmtFunctionDef<R>) {
self.generic_visit_stmt_FunctionDef(node)
fn visit_stmt_function_def(&mut self, node: StmtFunctionDef<R>) {
self.generic_visit_stmt_function_def(node)
}
fn generic_visit_stmt_FunctionDef(&mut self, node: StmtFunctionDef<R>) {
fn generic_visit_stmt_function_def(&mut self, node: StmtFunctionDef<R>) {
{
let value = node.args;
self.visit_arguments(*value);
self.visit_function_arguments(*value);
}
for value in node.body {
self.visit_stmt(value);
@ -54,13 +54,13 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(*value);
}
}
fn visit_stmt_AsyncFunctionDef(&mut self, node: StmtAsyncFunctionDef<R>) {
self.generic_visit_stmt_AsyncFunctionDef(node)
fn visit_stmt_async_function_def(&mut self, node: StmtAsyncFunctionDef<R>) {
self.generic_visit_stmt_async_function_def(node)
}
fn generic_visit_stmt_AsyncFunctionDef(&mut self, node: StmtAsyncFunctionDef<R>) {
fn generic_visit_stmt_async_function_def(&mut self, node: StmtAsyncFunctionDef<R>) {
{
let value = node.args;
self.visit_arguments(*value);
self.visit_function_arguments(*value);
}
for value in node.body {
self.visit_stmt(value);
@ -72,10 +72,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(*value);
}
}
fn visit_stmt_ClassDef(&mut self, node: StmtClassDef<R>) {
self.generic_visit_stmt_ClassDef(node)
fn visit_stmt_class_def(&mut self, node: StmtClassDef<R>) {
self.generic_visit_stmt_class_def(node)
}
fn generic_visit_stmt_ClassDef(&mut self, node: StmtClassDef<R>) {
fn generic_visit_stmt_class_def(&mut self, node: StmtClassDef<R>) {
for value in node.bases {
self.visit_expr(value);
}
@ -89,26 +89,26 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(value);
}
}
fn visit_stmt_Return(&mut self, node: StmtReturn<R>) {
self.generic_visit_stmt_Return(node)
fn visit_stmt_return(&mut self, node: StmtReturn<R>) {
self.generic_visit_stmt_return(node)
}
fn generic_visit_stmt_Return(&mut self, node: StmtReturn<R>) {
fn generic_visit_stmt_return(&mut self, node: StmtReturn<R>) {
if let Some(value) = node.value {
self.visit_expr(*value);
}
}
fn visit_stmt_Delete(&mut self, node: StmtDelete<R>) {
self.generic_visit_stmt_Delete(node)
fn visit_stmt_delete(&mut self, node: StmtDelete<R>) {
self.generic_visit_stmt_delete(node)
}
fn generic_visit_stmt_Delete(&mut self, node: StmtDelete<R>) {
fn generic_visit_stmt_delete(&mut self, node: StmtDelete<R>) {
for value in node.targets {
self.visit_expr(value);
}
}
fn visit_stmt_Assign(&mut self, node: StmtAssign<R>) {
self.generic_visit_stmt_Assign(node)
fn visit_stmt_assign(&mut self, node: StmtAssign<R>) {
self.generic_visit_stmt_assign(node)
}
fn generic_visit_stmt_Assign(&mut self, node: StmtAssign<R>) {
fn generic_visit_stmt_assign(&mut self, node: StmtAssign<R>) {
for value in node.targets {
self.visit_expr(value);
}
@ -117,10 +117,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(*value);
}
}
fn visit_stmt_AugAssign(&mut self, node: StmtAugAssign<R>) {
self.generic_visit_stmt_AugAssign(node)
fn visit_stmt_aug_assign(&mut self, node: StmtAugAssign<R>) {
self.generic_visit_stmt_aug_assign(node)
}
fn generic_visit_stmt_AugAssign(&mut self, node: StmtAugAssign<R>) {
fn generic_visit_stmt_aug_assign(&mut self, node: StmtAugAssign<R>) {
{
let value = node.target;
self.visit_expr(*value);
@ -130,10 +130,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(*value);
}
}
fn visit_stmt_AnnAssign(&mut self, node: StmtAnnAssign<R>) {
self.generic_visit_stmt_AnnAssign(node)
fn visit_stmt_ann_assign(&mut self, node: StmtAnnAssign<R>) {
self.generic_visit_stmt_ann_assign(node)
}
fn generic_visit_stmt_AnnAssign(&mut self, node: StmtAnnAssign<R>) {
fn generic_visit_stmt_ann_assign(&mut self, node: StmtAnnAssign<R>) {
{
let value = node.target;
self.visit_expr(*value);
@ -146,10 +146,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(*value);
}
}
fn visit_stmt_For(&mut self, node: StmtFor<R>) {
self.generic_visit_stmt_For(node)
fn visit_stmt_for(&mut self, node: StmtFor<R>) {
self.generic_visit_stmt_for(node)
}
fn generic_visit_stmt_For(&mut self, node: StmtFor<R>) {
fn generic_visit_stmt_for(&mut self, node: StmtFor<R>) {
{
let value = node.target;
self.visit_expr(*value);
@ -165,10 +165,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_stmt(value);
}
}
fn visit_stmt_AsyncFor(&mut self, node: StmtAsyncFor<R>) {
self.generic_visit_stmt_AsyncFor(node)
fn visit_stmt_async_for(&mut self, node: StmtAsyncFor<R>) {
self.generic_visit_stmt_async_for(node)
}
fn generic_visit_stmt_AsyncFor(&mut self, node: StmtAsyncFor<R>) {
fn generic_visit_stmt_async_for(&mut self, node: StmtAsyncFor<R>) {
{
let value = node.target;
self.visit_expr(*value);
@ -184,10 +184,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_stmt(value);
}
}
fn visit_stmt_While(&mut self, node: StmtWhile<R>) {
self.generic_visit_stmt_While(node)
fn visit_stmt_while(&mut self, node: StmtWhile<R>) {
self.generic_visit_stmt_while(node)
}
fn generic_visit_stmt_While(&mut self, node: StmtWhile<R>) {
fn generic_visit_stmt_while(&mut self, node: StmtWhile<R>) {
{
let value = node.test;
self.visit_expr(*value);
@ -199,10 +199,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_stmt(value);
}
}
fn visit_stmt_If(&mut self, node: StmtIf<R>) {
self.generic_visit_stmt_If(node)
fn visit_stmt_if(&mut self, node: StmtIf<R>) {
self.generic_visit_stmt_if(node)
}
fn generic_visit_stmt_If(&mut self, node: StmtIf<R>) {
fn generic_visit_stmt_if(&mut self, node: StmtIf<R>) {
{
let value = node.test;
self.visit_expr(*value);
@ -214,10 +214,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_stmt(value);
}
}
fn visit_stmt_With(&mut self, node: StmtWith<R>) {
self.generic_visit_stmt_With(node)
fn visit_stmt_with(&mut self, node: StmtWith<R>) {
self.generic_visit_stmt_with(node)
}
fn generic_visit_stmt_With(&mut self, node: StmtWith<R>) {
fn generic_visit_stmt_with(&mut self, node: StmtWith<R>) {
for value in node.items {
self.visit_withitem(value);
}
@ -225,10 +225,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_stmt(value);
}
}
fn visit_stmt_AsyncWith(&mut self, node: StmtAsyncWith<R>) {
self.generic_visit_stmt_AsyncWith(node)
fn visit_stmt_async_with(&mut self, node: StmtAsyncWith<R>) {
self.generic_visit_stmt_async_with(node)
}
fn generic_visit_stmt_AsyncWith(&mut self, node: StmtAsyncWith<R>) {
fn generic_visit_stmt_async_with(&mut self, node: StmtAsyncWith<R>) {
for value in node.items {
self.visit_withitem(value);
}
@ -236,10 +236,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_stmt(value);
}
}
fn visit_stmt_Match(&mut self, node: StmtMatch<R>) {
self.generic_visit_stmt_Match(node)
fn visit_stmt_match(&mut self, node: StmtMatch<R>) {
self.generic_visit_stmt_match(node)
}
fn generic_visit_stmt_Match(&mut self, node: StmtMatch<R>) {
fn generic_visit_stmt_match(&mut self, node: StmtMatch<R>) {
{
let value = node.subject;
self.visit_expr(*value);
@ -248,10 +248,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_match_case(value);
}
}
fn visit_stmt_Raise(&mut self, node: StmtRaise<R>) {
self.generic_visit_stmt_Raise(node)
fn visit_stmt_raise(&mut self, node: StmtRaise<R>) {
self.generic_visit_stmt_raise(node)
}
fn generic_visit_stmt_Raise(&mut self, node: StmtRaise<R>) {
fn generic_visit_stmt_raise(&mut self, node: StmtRaise<R>) {
if let Some(value) = node.exc {
self.visit_expr(*value);
}
@ -259,10 +259,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(*value);
}
}
fn visit_stmt_Try(&mut self, node: StmtTry<R>) {
self.generic_visit_stmt_Try(node)
fn visit_stmt_try(&mut self, node: StmtTry<R>) {
self.generic_visit_stmt_try(node)
}
fn generic_visit_stmt_Try(&mut self, node: StmtTry<R>) {
fn generic_visit_stmt_try(&mut self, node: StmtTry<R>) {
for value in node.body {
self.visit_stmt(value);
}
@ -276,10 +276,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_stmt(value);
}
}
fn visit_stmt_TryStar(&mut self, node: StmtTryStar<R>) {
self.generic_visit_stmt_TryStar(node)
fn visit_stmt_try_star(&mut self, node: StmtTryStar<R>) {
self.generic_visit_stmt_try_star(node)
}
fn generic_visit_stmt_TryStar(&mut self, node: StmtTryStar<R>) {
fn generic_visit_stmt_try_star(&mut self, node: StmtTryStar<R>) {
for value in node.body {
self.visit_stmt(value);
}
@ -293,10 +293,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_stmt(value);
}
}
fn visit_stmt_Assert(&mut self, node: StmtAssert<R>) {
self.generic_visit_stmt_Assert(node)
fn visit_stmt_assert(&mut self, node: StmtAssert<R>) {
self.generic_visit_stmt_assert(node)
}
fn generic_visit_stmt_Assert(&mut self, node: StmtAssert<R>) {
fn generic_visit_stmt_assert(&mut self, node: StmtAssert<R>) {
{
let value = node.test;
self.visit_expr(*value);
@ -305,88 +305,88 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(*value);
}
}
fn visit_stmt_Import(&mut self, node: StmtImport<R>) {
self.generic_visit_stmt_Import(node)
fn visit_stmt_import(&mut self, node: StmtImport<R>) {
self.generic_visit_stmt_import(node)
}
fn generic_visit_stmt_Import(&mut self, node: StmtImport<R>) {
fn generic_visit_stmt_import(&mut self, node: StmtImport<R>) {
for value in node.names {
self.visit_alias(value);
}
}
fn visit_stmt_ImportFrom(&mut self, node: StmtImportFrom<R>) {
self.generic_visit_stmt_ImportFrom(node)
fn visit_stmt_import_from(&mut self, node: StmtImportFrom<R>) {
self.generic_visit_stmt_import_from(node)
}
fn generic_visit_stmt_ImportFrom(&mut self, node: StmtImportFrom<R>) {
fn generic_visit_stmt_import_from(&mut self, node: StmtImportFrom<R>) {
for value in node.names {
self.visit_alias(value);
}
}
fn visit_stmt_Global(&mut self, node: StmtGlobal<R>) {
self.generic_visit_stmt_Global(node)
fn visit_stmt_global(&mut self, node: StmtGlobal<R>) {
self.generic_visit_stmt_global(node)
}
fn generic_visit_stmt_Global(&mut self, node: StmtGlobal<R>) {}
fn visit_stmt_Nonlocal(&mut self, node: StmtNonlocal<R>) {
self.generic_visit_stmt_Nonlocal(node)
fn generic_visit_stmt_global(&mut self, node: StmtGlobal<R>) {}
fn visit_stmt_nonlocal(&mut self, node: StmtNonlocal<R>) {
self.generic_visit_stmt_nonlocal(node)
}
fn generic_visit_stmt_Nonlocal(&mut self, node: StmtNonlocal<R>) {}
fn visit_stmt_Expr(&mut self, node: StmtExpr<R>) {
self.generic_visit_stmt_Expr(node)
fn generic_visit_stmt_nonlocal(&mut self, node: StmtNonlocal<R>) {}
fn visit_stmt_expr(&mut self, node: StmtExpr<R>) {
self.generic_visit_stmt_expr(node)
}
fn generic_visit_stmt_Expr(&mut self, node: StmtExpr<R>) {
fn generic_visit_stmt_expr(&mut self, node: StmtExpr<R>) {
{
let value = node.value;
self.visit_expr(*value);
}
}
fn visit_stmt_Pass(&mut self, node: StmtPass<R>) {}
fn visit_stmt_Break(&mut self, node: StmtBreak<R>) {}
fn visit_stmt_Continue(&mut self, node: StmtContinue<R>) {}
fn visit_stmt_pass(&mut self, node: StmtPass<R>) {}
fn visit_stmt_break(&mut self, node: StmtBreak<R>) {}
fn visit_stmt_continue(&mut self, node: StmtContinue<R>) {}
fn visit_expr(&mut self, node: Expr<R>) {
self.generic_visit_expr(node)
}
fn generic_visit_expr(&mut self, node: Expr<R>) {
match node {
Expr::BoolOp(data) => self.visit_expr_BoolOp(data),
Expr::NamedExpr(data) => self.visit_expr_NamedExpr(data),
Expr::BinOp(data) => self.visit_expr_BinOp(data),
Expr::UnaryOp(data) => self.visit_expr_UnaryOp(data),
Expr::Lambda(data) => self.visit_expr_Lambda(data),
Expr::IfExp(data) => self.visit_expr_IfExp(data),
Expr::Dict(data) => self.visit_expr_Dict(data),
Expr::Set(data) => self.visit_expr_Set(data),
Expr::ListComp(data) => self.visit_expr_ListComp(data),
Expr::SetComp(data) => self.visit_expr_SetComp(data),
Expr::DictComp(data) => self.visit_expr_DictComp(data),
Expr::GeneratorExp(data) => self.visit_expr_GeneratorExp(data),
Expr::Await(data) => self.visit_expr_Await(data),
Expr::Yield(data) => self.visit_expr_Yield(data),
Expr::YieldFrom(data) => self.visit_expr_YieldFrom(data),
Expr::Compare(data) => self.visit_expr_Compare(data),
Expr::Call(data) => self.visit_expr_Call(data),
Expr::FormattedValue(data) => self.visit_expr_FormattedValue(data),
Expr::JoinedStr(data) => self.visit_expr_JoinedStr(data),
Expr::Constant(data) => self.visit_expr_Constant(data),
Expr::Attribute(data) => self.visit_expr_Attribute(data),
Expr::Subscript(data) => self.visit_expr_Subscript(data),
Expr::Starred(data) => self.visit_expr_Starred(data),
Expr::Name(data) => self.visit_expr_Name(data),
Expr::List(data) => self.visit_expr_List(data),
Expr::Tuple(data) => self.visit_expr_Tuple(data),
Expr::Slice(data) => self.visit_expr_Slice(data),
Expr::BoolOp(data) => self.visit_expr_bool_op(data),
Expr::NamedExpr(data) => self.visit_expr_named_expr(data),
Expr::BinOp(data) => self.visit_expr_bin_op(data),
Expr::UnaryOp(data) => self.visit_expr_unary_op(data),
Expr::Lambda(data) => self.visit_expr_lambda(data),
Expr::IfExp(data) => self.visit_expr_if_exp(data),
Expr::Dict(data) => self.visit_expr_dict(data),
Expr::Set(data) => self.visit_expr_set(data),
Expr::ListComp(data) => self.visit_expr_list_comp(data),
Expr::SetComp(data) => self.visit_expr_set_comp(data),
Expr::DictComp(data) => self.visit_expr_dict_comp(data),
Expr::GeneratorExp(data) => self.visit_expr_generator_exp(data),
Expr::Await(data) => self.visit_expr_await(data),
Expr::Yield(data) => self.visit_expr_yield(data),
Expr::YieldFrom(data) => self.visit_expr_yield_from(data),
Expr::Compare(data) => self.visit_expr_compare(data),
Expr::Call(data) => self.visit_expr_call(data),
Expr::FormattedValue(data) => self.visit_expr_formatted_value(data),
Expr::JoinedStr(data) => self.visit_expr_joined_str(data),
Expr::Constant(data) => self.visit_expr_constant(data),
Expr::Attribute(data) => self.visit_expr_attribute(data),
Expr::Subscript(data) => self.visit_expr_subscript(data),
Expr::Starred(data) => self.visit_expr_starred(data),
Expr::Name(data) => self.visit_expr_name(data),
Expr::List(data) => self.visit_expr_list(data),
Expr::Tuple(data) => self.visit_expr_tuple(data),
Expr::Slice(data) => self.visit_expr_slice(data),
}
}
fn visit_expr_BoolOp(&mut self, node: ExprBoolOp<R>) {
self.generic_visit_expr_BoolOp(node)
fn visit_expr_bool_op(&mut self, node: ExprBoolOp<R>) {
self.generic_visit_expr_bool_op(node)
}
fn generic_visit_expr_BoolOp(&mut self, node: ExprBoolOp<R>) {
fn generic_visit_expr_bool_op(&mut self, node: ExprBoolOp<R>) {
for value in node.values {
self.visit_expr(value);
}
}
fn visit_expr_NamedExpr(&mut self, node: ExprNamedExpr<R>) {
self.generic_visit_expr_NamedExpr(node)
fn visit_expr_named_expr(&mut self, node: ExprNamedExpr<R>) {
self.generic_visit_expr_named_expr(node)
}
fn generic_visit_expr_NamedExpr(&mut self, node: ExprNamedExpr<R>) {
fn generic_visit_expr_named_expr(&mut self, node: ExprNamedExpr<R>) {
{
let value = node.target;
self.visit_expr(*value);
@ -396,10 +396,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(*value);
}
}
fn visit_expr_BinOp(&mut self, node: ExprBinOp<R>) {
self.generic_visit_expr_BinOp(node)
fn visit_expr_bin_op(&mut self, node: ExprBinOp<R>) {
self.generic_visit_expr_bin_op(node)
}
fn generic_visit_expr_BinOp(&mut self, node: ExprBinOp<R>) {
fn generic_visit_expr_bin_op(&mut self, node: ExprBinOp<R>) {
{
let value = node.left;
self.visit_expr(*value);
@ -409,32 +409,32 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(*value);
}
}
fn visit_expr_UnaryOp(&mut self, node: ExprUnaryOp<R>) {
self.generic_visit_expr_UnaryOp(node)
fn visit_expr_unary_op(&mut self, node: ExprUnaryOp<R>) {
self.generic_visit_expr_unary_op(node)
}
fn generic_visit_expr_UnaryOp(&mut self, node: ExprUnaryOp<R>) {
fn generic_visit_expr_unary_op(&mut self, node: ExprUnaryOp<R>) {
{
let value = node.operand;
self.visit_expr(*value);
}
}
fn visit_expr_Lambda(&mut self, node: ExprLambda<R>) {
self.generic_visit_expr_Lambda(node)
fn visit_expr_lambda(&mut self, node: ExprLambda<R>) {
self.generic_visit_expr_lambda(node)
}
fn generic_visit_expr_Lambda(&mut self, node: ExprLambda<R>) {
fn generic_visit_expr_lambda(&mut self, node: ExprLambda<R>) {
{
let value = node.args;
self.visit_arguments(*value);
self.visit_function_arguments(*value);
}
{
let value = node.body;
self.visit_expr(*value);
}
}
fn visit_expr_IfExp(&mut self, node: ExprIfExp<R>) {
self.generic_visit_expr_IfExp(node)
fn visit_expr_if_exp(&mut self, node: ExprIfExp<R>) {
self.generic_visit_expr_if_exp(node)
}
fn generic_visit_expr_IfExp(&mut self, node: ExprIfExp<R>) {
fn generic_visit_expr_if_exp(&mut self, node: ExprIfExp<R>) {
{
let value = node.test;
self.visit_expr(*value);
@ -448,10 +448,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(*value);
}
}
fn visit_expr_Dict(&mut self, node: ExprDict<R>) {
self.generic_visit_expr_Dict(node)
fn visit_expr_dict(&mut self, node: ExprDict<R>) {
self.generic_visit_expr_dict(node)
}
fn generic_visit_expr_Dict(&mut self, node: ExprDict<R>) {
fn generic_visit_expr_dict(&mut self, node: ExprDict<R>) {
for value in node.keys.into_iter().flatten() {
self.visit_expr(value);
}
@ -459,18 +459,18 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(value);
}
}
fn visit_expr_Set(&mut self, node: ExprSet<R>) {
self.generic_visit_expr_Set(node)
fn visit_expr_set(&mut self, node: ExprSet<R>) {
self.generic_visit_expr_set(node)
}
fn generic_visit_expr_Set(&mut self, node: ExprSet<R>) {
fn generic_visit_expr_set(&mut self, node: ExprSet<R>) {
for value in node.elts {
self.visit_expr(value);
}
}
fn visit_expr_ListComp(&mut self, node: ExprListComp<R>) {
self.generic_visit_expr_ListComp(node)
fn visit_expr_list_comp(&mut self, node: ExprListComp<R>) {
self.generic_visit_expr_list_comp(node)
}
fn generic_visit_expr_ListComp(&mut self, node: ExprListComp<R>) {
fn generic_visit_expr_list_comp(&mut self, node: ExprListComp<R>) {
{
let value = node.elt;
self.visit_expr(*value);
@ -479,10 +479,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_comprehension(value);
}
}
fn visit_expr_SetComp(&mut self, node: ExprSetComp<R>) {
self.generic_visit_expr_SetComp(node)
fn visit_expr_set_comp(&mut self, node: ExprSetComp<R>) {
self.generic_visit_expr_set_comp(node)
}
fn generic_visit_expr_SetComp(&mut self, node: ExprSetComp<R>) {
fn generic_visit_expr_set_comp(&mut self, node: ExprSetComp<R>) {
{
let value = node.elt;
self.visit_expr(*value);
@ -491,10 +491,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_comprehension(value);
}
}
fn visit_expr_DictComp(&mut self, node: ExprDictComp<R>) {
self.generic_visit_expr_DictComp(node)
fn visit_expr_dict_comp(&mut self, node: ExprDictComp<R>) {
self.generic_visit_expr_dict_comp(node)
}
fn generic_visit_expr_DictComp(&mut self, node: ExprDictComp<R>) {
fn generic_visit_expr_dict_comp(&mut self, node: ExprDictComp<R>) {
{
let value = node.key;
self.visit_expr(*value);
@ -507,10 +507,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_comprehension(value);
}
}
fn visit_expr_GeneratorExp(&mut self, node: ExprGeneratorExp<R>) {
self.generic_visit_expr_GeneratorExp(node)
fn visit_expr_generator_exp(&mut self, node: ExprGeneratorExp<R>) {
self.generic_visit_expr_generator_exp(node)
}
fn generic_visit_expr_GeneratorExp(&mut self, node: ExprGeneratorExp<R>) {
fn generic_visit_expr_generator_exp(&mut self, node: ExprGeneratorExp<R>) {
{
let value = node.elt;
self.visit_expr(*value);
@ -519,36 +519,36 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_comprehension(value);
}
}
fn visit_expr_Await(&mut self, node: ExprAwait<R>) {
self.generic_visit_expr_Await(node)
fn visit_expr_await(&mut self, node: ExprAwait<R>) {
self.generic_visit_expr_await(node)
}
fn generic_visit_expr_Await(&mut self, node: ExprAwait<R>) {
fn generic_visit_expr_await(&mut self, node: ExprAwait<R>) {
{
let value = node.value;
self.visit_expr(*value);
}
}
fn visit_expr_Yield(&mut self, node: ExprYield<R>) {
self.generic_visit_expr_Yield(node)
fn visit_expr_yield(&mut self, node: ExprYield<R>) {
self.generic_visit_expr_yield(node)
}
fn generic_visit_expr_Yield(&mut self, node: ExprYield<R>) {
fn generic_visit_expr_yield(&mut self, node: ExprYield<R>) {
if let Some(value) = node.value {
self.visit_expr(*value);
}
}
fn visit_expr_YieldFrom(&mut self, node: ExprYieldFrom<R>) {
self.generic_visit_expr_YieldFrom(node)
fn visit_expr_yield_from(&mut self, node: ExprYieldFrom<R>) {
self.generic_visit_expr_yield_from(node)
}
fn generic_visit_expr_YieldFrom(&mut self, node: ExprYieldFrom<R>) {
fn generic_visit_expr_yield_from(&mut self, node: ExprYieldFrom<R>) {
{
let value = node.value;
self.visit_expr(*value);
}
}
fn visit_expr_Compare(&mut self, node: ExprCompare<R>) {
self.generic_visit_expr_Compare(node)
fn visit_expr_compare(&mut self, node: ExprCompare<R>) {
self.generic_visit_expr_compare(node)
}
fn generic_visit_expr_Compare(&mut self, node: ExprCompare<R>) {
fn generic_visit_expr_compare(&mut self, node: ExprCompare<R>) {
{
let value = node.left;
self.visit_expr(*value);
@ -557,10 +557,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(value);
}
}
fn visit_expr_Call(&mut self, node: ExprCall<R>) {
self.generic_visit_expr_Call(node)
fn visit_expr_call(&mut self, node: ExprCall<R>) {
self.generic_visit_expr_call(node)
}
fn generic_visit_expr_Call(&mut self, node: ExprCall<R>) {
fn generic_visit_expr_call(&mut self, node: ExprCall<R>) {
{
let value = node.func;
self.visit_expr(*value);
@ -572,10 +572,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_keyword(value);
}
}
fn visit_expr_FormattedValue(&mut self, node: ExprFormattedValue<R>) {
self.generic_visit_expr_FormattedValue(node)
fn visit_expr_formatted_value(&mut self, node: ExprFormattedValue<R>) {
self.generic_visit_expr_formatted_value(node)
}
fn generic_visit_expr_FormattedValue(&mut self, node: ExprFormattedValue<R>) {
fn generic_visit_expr_formatted_value(&mut self, node: ExprFormattedValue<R>) {
{
let value = node.value;
self.visit_expr(*value);
@ -584,31 +584,31 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(*value);
}
}
fn visit_expr_JoinedStr(&mut self, node: ExprJoinedStr<R>) {
self.generic_visit_expr_JoinedStr(node)
fn visit_expr_joined_str(&mut self, node: ExprJoinedStr<R>) {
self.generic_visit_expr_joined_str(node)
}
fn generic_visit_expr_JoinedStr(&mut self, node: ExprJoinedStr<R>) {
fn generic_visit_expr_joined_str(&mut self, node: ExprJoinedStr<R>) {
for value in node.values {
self.visit_expr(value);
}
}
fn visit_expr_Constant(&mut self, node: ExprConstant<R>) {
self.generic_visit_expr_Constant(node)
fn visit_expr_constant(&mut self, node: ExprConstant<R>) {
self.generic_visit_expr_constant(node)
}
fn generic_visit_expr_Constant(&mut self, node: ExprConstant<R>) {}
fn visit_expr_Attribute(&mut self, node: ExprAttribute<R>) {
self.generic_visit_expr_Attribute(node)
fn generic_visit_expr_constant(&mut self, node: ExprConstant<R>) {}
fn visit_expr_attribute(&mut self, node: ExprAttribute<R>) {
self.generic_visit_expr_attribute(node)
}
fn generic_visit_expr_Attribute(&mut self, node: ExprAttribute<R>) {
fn generic_visit_expr_attribute(&mut self, node: ExprAttribute<R>) {
{
let value = node.value;
self.visit_expr(*value);
}
}
fn visit_expr_Subscript(&mut self, node: ExprSubscript<R>) {
self.generic_visit_expr_Subscript(node)
fn visit_expr_subscript(&mut self, node: ExprSubscript<R>) {
self.generic_visit_expr_subscript(node)
}
fn generic_visit_expr_Subscript(&mut self, node: ExprSubscript<R>) {
fn generic_visit_expr_subscript(&mut self, node: ExprSubscript<R>) {
{
let value = node.value;
self.visit_expr(*value);
@ -618,39 +618,39 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(*value);
}
}
fn visit_expr_Starred(&mut self, node: ExprStarred<R>) {
self.generic_visit_expr_Starred(node)
fn visit_expr_starred(&mut self, node: ExprStarred<R>) {
self.generic_visit_expr_starred(node)
}
fn generic_visit_expr_Starred(&mut self, node: ExprStarred<R>) {
fn generic_visit_expr_starred(&mut self, node: ExprStarred<R>) {
{
let value = node.value;
self.visit_expr(*value);
}
}
fn visit_expr_Name(&mut self, node: ExprName<R>) {
self.generic_visit_expr_Name(node)
fn visit_expr_name(&mut self, node: ExprName<R>) {
self.generic_visit_expr_name(node)
}
fn generic_visit_expr_Name(&mut self, node: ExprName<R>) {}
fn visit_expr_List(&mut self, node: ExprList<R>) {
self.generic_visit_expr_List(node)
fn generic_visit_expr_name(&mut self, node: ExprName<R>) {}
fn visit_expr_list(&mut self, node: ExprList<R>) {
self.generic_visit_expr_list(node)
}
fn generic_visit_expr_List(&mut self, node: ExprList<R>) {
fn generic_visit_expr_list(&mut self, node: ExprList<R>) {
for value in node.elts {
self.visit_expr(value);
}
}
fn visit_expr_Tuple(&mut self, node: ExprTuple<R>) {
self.generic_visit_expr_Tuple(node)
fn visit_expr_tuple(&mut self, node: ExprTuple<R>) {
self.generic_visit_expr_tuple(node)
}
fn generic_visit_expr_Tuple(&mut self, node: ExprTuple<R>) {
fn generic_visit_expr_tuple(&mut self, node: ExprTuple<R>) {
for value in node.elts {
self.visit_expr(value);
}
}
fn visit_expr_Slice(&mut self, node: ExprSlice<R>) {
self.generic_visit_expr_Slice(node)
fn visit_expr_slice(&mut self, node: ExprSlice<R>) {
self.generic_visit_expr_slice(node)
}
fn generic_visit_expr_Slice(&mut self, node: ExprSlice<R>) {
fn generic_visit_expr_slice(&mut self, node: ExprSlice<R>) {
if let Some(value) = node.lower {
self.visit_expr(*value);
}
@ -690,13 +690,13 @@ pub trait Visitor<R = crate::text_size::TextRange> {
}
fn generic_visit_excepthandler(&mut self, node: Excepthandler<R>) {
match node {
Excepthandler::ExceptHandler(data) => self.visit_excepthandler_ExceptHandler(data),
Excepthandler::ExceptHandler(data) => self.visit_excepthandler_except_handler(data),
}
}
fn visit_excepthandler_ExceptHandler(&mut self, node: ExcepthandlerExceptHandler<R>) {
self.generic_visit_excepthandler_ExceptHandler(node)
fn visit_excepthandler_except_handler(&mut self, node: ExcepthandlerExceptHandler<R>) {
self.generic_visit_excepthandler_except_handler(node)
}
fn generic_visit_excepthandler_ExceptHandler(&mut self, node: ExcepthandlerExceptHandler<R>) {
fn generic_visit_excepthandler_except_handler(&mut self, node: ExcepthandlerExceptHandler<R>) {
if let Some(value) = node.type_ {
self.visit_expr(*value);
}
@ -733,41 +733,41 @@ pub trait Visitor<R = crate::text_size::TextRange> {
}
fn generic_visit_pattern(&mut self, node: Pattern<R>) {
match node {
Pattern::MatchValue(data) => self.visit_pattern_MatchValue(data),
Pattern::MatchSingleton(data) => self.visit_pattern_MatchSingleton(data),
Pattern::MatchSequence(data) => self.visit_pattern_MatchSequence(data),
Pattern::MatchMapping(data) => self.visit_pattern_MatchMapping(data),
Pattern::MatchClass(data) => self.visit_pattern_MatchClass(data),
Pattern::MatchStar(data) => self.visit_pattern_MatchStar(data),
Pattern::MatchAs(data) => self.visit_pattern_MatchAs(data),
Pattern::MatchOr(data) => self.visit_pattern_MatchOr(data),
Pattern::MatchValue(data) => self.visit_pattern_match_value(data),
Pattern::MatchSingleton(data) => self.visit_pattern_match_singleton(data),
Pattern::MatchSequence(data) => self.visit_pattern_match_sequence(data),
Pattern::MatchMapping(data) => self.visit_pattern_match_mapping(data),
Pattern::MatchClass(data) => self.visit_pattern_match_class(data),
Pattern::MatchStar(data) => self.visit_pattern_match_star(data),
Pattern::MatchAs(data) => self.visit_pattern_match_as(data),
Pattern::MatchOr(data) => self.visit_pattern_match_or(data),
}
}
fn visit_pattern_MatchValue(&mut self, node: PatternMatchValue<R>) {
self.generic_visit_pattern_MatchValue(node)
fn visit_pattern_match_value(&mut self, node: PatternMatchValue<R>) {
self.generic_visit_pattern_match_value(node)
}
fn generic_visit_pattern_MatchValue(&mut self, node: PatternMatchValue<R>) {
fn generic_visit_pattern_match_value(&mut self, node: PatternMatchValue<R>) {
{
let value = node.value;
self.visit_expr(*value);
}
}
fn visit_pattern_MatchSingleton(&mut self, node: PatternMatchSingleton<R>) {
self.generic_visit_pattern_MatchSingleton(node)
fn visit_pattern_match_singleton(&mut self, node: PatternMatchSingleton<R>) {
self.generic_visit_pattern_match_singleton(node)
}
fn generic_visit_pattern_MatchSingleton(&mut self, node: PatternMatchSingleton<R>) {}
fn visit_pattern_MatchSequence(&mut self, node: PatternMatchSequence<R>) {
self.generic_visit_pattern_MatchSequence(node)
fn generic_visit_pattern_match_singleton(&mut self, node: PatternMatchSingleton<R>) {}
fn visit_pattern_match_sequence(&mut self, node: PatternMatchSequence<R>) {
self.generic_visit_pattern_match_sequence(node)
}
fn generic_visit_pattern_MatchSequence(&mut self, node: PatternMatchSequence<R>) {
fn generic_visit_pattern_match_sequence(&mut self, node: PatternMatchSequence<R>) {
for value in node.patterns {
self.visit_pattern(value);
}
}
fn visit_pattern_MatchMapping(&mut self, node: PatternMatchMapping<R>) {
self.generic_visit_pattern_MatchMapping(node)
fn visit_pattern_match_mapping(&mut self, node: PatternMatchMapping<R>) {
self.generic_visit_pattern_match_mapping(node)
}
fn generic_visit_pattern_MatchMapping(&mut self, node: PatternMatchMapping<R>) {
fn generic_visit_pattern_match_mapping(&mut self, node: PatternMatchMapping<R>) {
for value in node.keys {
self.visit_expr(value);
}
@ -775,10 +775,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_pattern(value);
}
}
fn visit_pattern_MatchClass(&mut self, node: PatternMatchClass<R>) {
self.generic_visit_pattern_MatchClass(node)
fn visit_pattern_match_class(&mut self, node: PatternMatchClass<R>) {
self.generic_visit_pattern_match_class(node)
}
fn generic_visit_pattern_MatchClass(&mut self, node: PatternMatchClass<R>) {
fn generic_visit_pattern_match_class(&mut self, node: PatternMatchClass<R>) {
{
let value = node.cls;
self.visit_expr(*value);
@ -790,24 +790,32 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_pattern(value);
}
}
fn visit_pattern_MatchStar(&mut self, node: PatternMatchStar<R>) {
self.generic_visit_pattern_MatchStar(node)
fn visit_pattern_match_star(&mut self, node: PatternMatchStar<R>) {
self.generic_visit_pattern_match_star(node)
}
fn generic_visit_pattern_MatchStar(&mut self, node: PatternMatchStar<R>) {}
fn visit_pattern_MatchAs(&mut self, node: PatternMatchAs<R>) {
self.generic_visit_pattern_MatchAs(node)
fn generic_visit_pattern_match_star(&mut self, node: PatternMatchStar<R>) {}
fn visit_pattern_match_as(&mut self, node: PatternMatchAs<R>) {
self.generic_visit_pattern_match_as(node)
}
fn generic_visit_pattern_MatchAs(&mut self, node: PatternMatchAs<R>) {
fn generic_visit_pattern_match_as(&mut self, node: PatternMatchAs<R>) {
if let Some(value) = node.pattern {
self.visit_pattern(*value);
}
}
fn visit_pattern_MatchOr(&mut self, node: PatternMatchOr<R>) {
self.generic_visit_pattern_MatchOr(node)
fn visit_pattern_match_or(&mut self, node: PatternMatchOr<R>) {
self.generic_visit_pattern_match_or(node)
}
fn generic_visit_pattern_MatchOr(&mut self, node: PatternMatchOr<R>) {
fn generic_visit_pattern_match_or(&mut self, node: PatternMatchOr<R>) {
for value in node.patterns {
self.visit_pattern(value);
}
}
fn visit_function_arguments(&mut self, node: FunctionArguments<R>) {
self.generic_visit_function_arguments(node)
}
fn generic_visit_function_arguments(&mut self, node: FunctionArguments<R>) {}
fn visit_arg_with_default(&mut self, node: ArgWithDefault<R>) {
self.generic_visit_arg_with_default(node)
}
fn generic_visit_arg_with_default(&mut self, node: ArgWithDefault<R>) {}
}

256
ast/src/generic.rs
View file

@ -11,6 +11,15 @@ pub type OptionalRange<R> = R;
#[cfg(not(feature = "all-nodes-with-ranges"))]
pub type OptionalRange<R> = EmptyRange<R>;
#[cfg(not(feature = "all-nodes-with-ranges"))]
impl<R> From<R> for OptionalRange<R> {
fn from(_: R) -> Self {
Self {
phantom: PhantomData,
}
}
}
#[derive(Eq, PartialEq, Hash, Copy, Clone)]
pub struct EmptyRange<R> {
phantom: PhantomData<R>,
@ -62,4 +71,251 @@ impl Cmpop {
}
}
impl<R> FunctionArguments<R> {
pub fn empty(range: OptionalRange<R>) -> Self {
Self {
range,
posonlyargs: Vec::new(),
args: Vec::new(),
vararg: None,
kwonlyargs: Vec::new(),
kwarg: None,
}
}
}
#[allow(clippy::borrowed_box)] // local utility
fn clone_boxed_expr<R: Clone>(expr: &Box<Expr<R>>) -> Box<Expr<R>> {
let expr: &Expr<_> = expr.as_ref();
Box::new(expr.clone())
}
impl<R> ArgWithDefault<R> {
pub fn from_arg(def: Arg<R>, default: Option<Expr<R>>) -> Self
where
R: Clone,
{
#[allow(clippy::useless_conversion)] // false positive due to cfg
let range = OptionalRange::from(def.range.clone()); // FIXME: def.range.start()..default.range.end()
Self {
range,
def,
default: default.map(Box::new),
}
}
pub fn as_arg(&self) -> &Arg<R> {
&self.def
}
pub fn to_arg(&self) -> (Arg<R>, Option<Box<Expr<R>>>)
where
R: Clone,
{
let ArgWithDefault {
range: _,
def,
default,
} = self;
(def.clone(), default.as_ref().map(clone_boxed_expr))
}
pub fn into_arg(self) -> (Arg<R>, Option<Box<Expr<R>>>) {
let ArgWithDefault {
range: _,
def,
default,
} = self;
(def, default)
}
}
impl<R> FunctionArguments<R> {
pub fn defaults(&self) -> impl std::iter::Iterator<Item = &Expr<R>> {
self.posonlyargs
.iter()
.chain(self.args.iter())
.filter_map(|arg| arg.default.as_ref().map(|e| e.as_ref()))
}
#[allow(clippy::type_complexity)]
pub fn split_kwonlyargs(&self) -> (Vec<&Arg<R>>, Vec<(&Arg<R>, &Expr<R>)>) {
let mut args = Vec::new();
let mut with_defaults = Vec::new();
for arg in self.kwonlyargs.iter() {
if let Some(ref default) = arg.default {
with_defaults.push((arg.as_arg(), &**default));
} else {
args.push(arg.as_arg());
}
}
(args, with_defaults)
}
pub fn to_arguments(&self) -> Arguments<R>
where
R: Clone,
{
let FunctionArguments {
range,
posonlyargs,
args,
vararg,
kwonlyargs,
kwarg,
} = self;
let mut pos_only = Vec::with_capacity(posonlyargs.len());
let mut pos_args = Vec::with_capacity(args.len());
let mut defaults = Vec::new();
for arg in posonlyargs {
let (arg, default) = arg.to_arg();
if let Some(default) = default {
defaults.push(*default);
}
pos_only.push(arg);
}
for arg in args {
let (arg, default) = arg.to_arg();
if let Some(default) = default {
defaults.push(*default);
}
pos_args.push(arg);
}
let mut kw_only = Vec::with_capacity(kwonlyargs.len());
let mut kw_defaults = Vec::new();
for arg in kwonlyargs {
let (arg, default) = arg.to_arg();
if let Some(default) = default {
kw_defaults.push(*default);
}
kw_only.push(arg);
}
Arguments {
range: range.clone(),
posonlyargs: pos_only,
args: pos_args,
defaults,
vararg: vararg.clone(),
kwonlyargs: kw_only,
kw_defaults,
kwarg: kwarg.clone(),
}
}
pub fn into_arguments(self) -> Arguments<R> {
let FunctionArguments {
range,
posonlyargs,
args,
vararg,
kwonlyargs,
kwarg,
} = self;
let mut pos_only = Vec::with_capacity(posonlyargs.len());
let mut pos_args = Vec::with_capacity(args.len());
let mut defaults = Vec::new();
for arg in posonlyargs {
let (arg, default) = arg.into_arg();
if let Some(default) = default {
defaults.push(*default);
}
pos_only.push(arg);
}
for arg in args {
let (arg, default) = arg.into_arg();
if let Some(default) = default {
defaults.push(*default);
}
pos_args.push(arg);
}
let mut kw_only = Vec::with_capacity(kwonlyargs.len());
let mut kw_defaults = Vec::new();
for arg in kwonlyargs {
let (arg, default) = arg.into_arg();
if let Some(default) = default {
kw_defaults.push(*default);
}
kw_only.push(arg);
}
Arguments {
range,
posonlyargs: pos_only,
args: pos_args,
defaults,
vararg,
kwonlyargs: kw_only,
kw_defaults,
kwarg,
}
}
}
impl<R> Arguments<R> {
pub fn into_function_arguments(self) -> FunctionArguments<R>
where
R: Clone,
{
let Arguments {
range,
posonlyargs,
args,
defaults,
vararg,
kwonlyargs,
kw_defaults,
kwarg,
} = self;
let mut pos_only = Vec::with_capacity(posonlyargs.len());
let mut pos_args = Vec::with_capacity(args.len());
let args_len = posonlyargs.len() + args.len();
// not optimal
let mut defaults: Vec<_> = std::iter::repeat_with(|| None)
.take(args_len - defaults.len())
.chain(defaults.into_iter().map(Some))
.collect();
debug_assert_eq!(args_len, defaults.len());
for (arg, default) in std::iter::zip(args, defaults.drain(posonlyargs.len()..)) {
let arg = ArgWithDefault::from_arg(arg, default);
pos_args.push(arg);
}
for (arg, default) in std::iter::zip(posonlyargs, defaults.drain(..)) {
let arg = ArgWithDefault::from_arg(arg, default);
pos_only.push(arg);
}
let mut kw_only = Vec::with_capacity(kwonlyargs.len());
let kw_defaults: Vec<_> = std::iter::repeat_with(|| None)
.take(kw_only.len().saturating_sub(kw_defaults.len()))
.chain(kw_defaults.into_iter().map(Some))
.collect();
for (arg, default) in std::iter::zip(kwonlyargs, kw_defaults) {
let arg = ArgWithDefault::from_arg(arg, default);
kw_only.push(arg);
}
FunctionArguments {
range,
posonlyargs: pos_only,
args: pos_args,
vararg,
kwonlyargs: kw_only,
kwarg,
}
}
}
impl<R> From<FunctionArguments<R>> for Arguments<R> {
fn from(arguments: FunctionArguments<R>) -> Self {
arguments.into_arguments()
}
}
include!("gen/generic.rs");

47
ast/src/unparse.rs
View file

@ -1,5 +1,7 @@
use crate::ConversionFlag;
use crate::{Arg, Arguments, Boolop, Comprehension, Constant, Expr, Identifier, Operator};
use crate::{
Arg, Arguments, Boolop, Cmpop, Comprehension, Constant, ConversionFlag, Expr, ArgWithDefault,
FunctionArguments, Identifier, Operator,
};
use std::fmt;
mod precedence {
@ -155,7 +157,7 @@ impl<'a> Unparser<'a> {
group_if!(precedence::TEST, {
let pos = args.args.len() + args.posonlyargs.len();
self.p(if pos > 0 { "lambda " } else { "lambda" })?;
self.unparse_args(args)?;
self.unparse_function_arguments(args)?;
write!(self, ": {}", **body)?;
})
}
@ -437,7 +439,44 @@ impl<'a> Unparser<'a> {
Ok(())
}
fn unparse_args<U>(&mut self, args: &Arguments<U>) -> fmt::Result {
fn unparse_function_arguments<U>(&mut self, args: &FunctionArguments<U>) -> fmt::Result {
let mut first = true;
for (i, arg) in args.posonlyargs.iter().chain(&args.args).enumerate() {
self.p_delim(&mut first, ", ")?;
self.unparse_function_arg(arg)?;
self.p_if(i + 1 == args.posonlyargs.len(), ", /")?;
}
if args.vararg.is_some() || !args.kwonlyargs.is_empty() {
self.p_delim(&mut first, ", ")?;
self.p("*")?;
}
if let Some(vararg) = &args.vararg {
self.unparse_arg(vararg)?;
}
for kwarg in args.kwonlyargs.iter() {
self.p_delim(&mut first, ", ")?;
self.unparse_function_arg(kwarg)?;
}
if let Some(kwarg) = &args.kwarg {
self.p_delim(&mut first, ", ")?;
self.p("**")?;
self.unparse_arg(kwarg)?;
}
Ok(())
}
fn unparse_function_arg<U>(&mut self, arg: &ArgWithDefault<U>) -> fmt::Result {
self.p_id(&arg.def.arg)?;
if let Some(ann) = &arg.def.annotation {
write!(self, ": {}", **ann)?;
}
if let Some(default) = &arg.default {
write!(self, "={}", default)?;
}
Ok(())
}
#[allow(dead_code)]
fn unparse_arguments<U>(&mut self, args: &Arguments<U>) -> fmt::Result {
let mut first = true;
let defaults_start = args.posonlyargs.len() + args.args.len() - args.defaults.len();
for (i, arg) in args.posonlyargs.iter().chain(&args.args).enumerate() {

8
parser/src/context.rs
View file

@ -66,7 +66,7 @@ mod tests {
}
#[test]
#[cfg(not(feature = "all-nodes-with-ranges"))]
#[cfg(feature = "all-nodes-with-ranges")]
fn test_assign_list() {
let source = "[x, y] = (1, 2, 3)";
let parse_ast = ast::Suite::parse(source, "<test>").unwrap();
@ -102,7 +102,7 @@ mod tests {
}
#[test]
#[cfg(not(feature = "all-nodes-with-ranges"))]
#[cfg(feature = "all-nodes-with-ranges")]
fn test_assign_list_comp() {
let source = "x = [y for y in (1, 2, 3)]";
let parse_ast = ast::Suite::parse(source, "<test>").unwrap();
@ -110,7 +110,7 @@ mod tests {
}
#[test]
#[cfg(not(feature = "all-nodes-with-ranges"))]
#[cfg(feature = "all-nodes-with-ranges")]
fn test_assign_set_comp() {
let source = "x = {y for y in (1, 2, 3)}";
let parse_ast = ast::Suite::parse(source, "<test>").unwrap();
@ -118,7 +118,7 @@ mod tests {
}
#[test]
#[cfg(not(feature = "all-nodes-with-ranges"))]
#[cfg(feature = "all-nodes-with-ranges")]
fn test_assign_with() {
let source = "with 1 as x: pass";
let parse_ast = ast::Suite::parse(source, "<test>").unwrap();

102
parser/src/function.rs
View file

@ -14,76 +14,58 @@ pub(crate) struct ArgumentList {
pub keywords: Vec<ast::Keyword>,
}
type ParameterDefs = (Vec<ast::Arg>, Vec<ast::Arg>, Vec<ast::Expr>);
type ParameterDef = (ast::Arg, Option<ast::Expr>);
// Perform validation of function/lambda arguments in a function definition.
pub(crate) fn validate_arguments(
arguments: ast::Arguments,
) -> Result<ast::Arguments, LexicalError> {
let mut all_args: Vec<&ast::Arg> = vec![];
all_args.extend(arguments.posonlyargs.iter());
all_args.extend(arguments.args.iter());
if let Some(a) = &arguments.vararg {
all_args.push(a);
}
all_args.extend(arguments.kwonlyargs.iter());
if let Some(a) = &arguments.kwarg {
all_args.push(a);
}
pub(crate) fn validate_arguments(arguments: &ast::FunctionArguments) -> Result<(), LexicalError> {
let mut all_arg_names = FxHashSet::with_hasher(Default::default());
for arg in all_args {
let arg_name = &arg.arg;
// Check for duplicate arguments in the function definition.
for (range, arg_name) in arguments
.posonlyargs
.iter()
.chain(arguments.args.iter())
.chain(arguments.kwonlyargs.iter())
.map(|arg| (arg.def.range, arg.def.arg.as_str()))
.chain(
arguments
.vararg
.as_ref()
.map(|arg| (arg.range, arg.arg.as_str())),
)
.chain(
arguments
.kwarg
.as_ref()
.map(|arg| (arg.range, arg.arg.as_str())),
)
{
if !all_arg_names.insert(arg_name) {
return Err(LexicalError {
error: LexicalErrorType::DuplicateArgumentError(arg_name.to_string()),
location: arg.start(),
location: range.start(),
});
}
}
Ok(arguments)
Ok(())
}
// Parse parameters as supplied during a function/lambda *definition*.
pub(crate) fn parse_params(
params: (Vec<ParameterDef>, Vec<ParameterDef>),
) -> Result<ParameterDefs, LexicalError> {
let mut pos_only = Vec::with_capacity(params.0.len());
let mut names = Vec::with_capacity(params.1.len());
let mut defaults = vec![];
let mut try_default = |name: &ast::Arg, default| {
if let Some(default) = default {
defaults.push(default);
} else if !defaults.is_empty() {
// Once we have started with defaults, all remaining arguments must
// have defaults.
return Err(LexicalError {
error: LexicalErrorType::DefaultArgumentError,
location: name.start(),
});
}
Ok(())
};
for (name, default) in params.0 {
try_default(&name, default)?;
pos_only.push(name);
pub(crate) fn validate_pos_params(
args: &(Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
) -> Result<(), LexicalError> {
let (posonlyargs, args) = args;
#[allow(clippy::skip_while_next)]
let first_invalid = posonlyargs
.iter()
.chain(args.iter()) // for all args
.skip_while(|arg| arg.default.is_none()) // starting with args without default
.skip_while(|arg| arg.default.is_some()) // and then args with default
.next(); // there must not be any more args without default
if let Some(invalid) = first_invalid {
return Err(LexicalError {
error: LexicalErrorType::DefaultArgumentError,
location: invalid.def.range.start(),
});
}
for (name, default) in params.1 {
try_default(&name, default)?;
names.push(name);
}
Ok((pos_only, names, defaults))
Ok(())
}
type FunctionArgument = (
@ -157,7 +139,7 @@ mod tests {
use super::*;
use crate::{ast, parser::ParseErrorType, Parse};
#[cfg(not(feature = "all-nodes-with-ranges"))]
#[cfg(feature = "all-nodes-with-ranges")]
macro_rules! function_and_lambda {
($($name:ident: $code:expr,)*) => {
$(
@ -170,7 +152,7 @@ mod tests {
}
}
#[cfg(not(feature = "all-nodes-with-ranges"))]
#[cfg(feature = "all-nodes-with-ranges")]
function_and_lambda! {
test_function_no_args: "def f(): pass",
test_function_pos_args: "def f(a, b, c): pass",

28
parser/src/parser.rs
View file

@ -610,7 +610,7 @@ mod tests {
}
#[test]
#[cfg(not(feature = "all-nodes-with-ranges"))]
#[cfg(feature = "all-nodes-with-ranges")]
fn test_parse_lambda() {
let source = "lambda x, y: x * y"; // lambda(x, y): x * y";
let parse_ast = ast::Suite::parse(source, "<test>").unwrap();
@ -625,7 +625,7 @@ mod tests {
}
#[test]
#[cfg(not(feature = "all-nodes-with-ranges"))]
#[cfg(feature = "all-nodes-with-ranges")]
fn test_parse_class() {
let source = "\
class Foo(A, B):
@ -638,7 +638,7 @@ class Foo(A, B):
}
#[test]
#[cfg(not(feature = "all-nodes-with-ranges"))]
#[cfg(feature = "all-nodes-with-ranges")]
fn test_parse_dict_comprehension() {
let source = "{x1: x2 for y in z}";
let parse_ast = ast::Expr::parse(source, "<test>").unwrap();
@ -646,7 +646,7 @@ class Foo(A, B):
}
#[test]
#[cfg(not(feature = "all-nodes-with-ranges"))]
#[cfg(feature = "all-nodes-with-ranges")]
fn test_parse_list_comprehension() {
let source = "[x for y in z]";
let parse_ast = ast::Expr::parse(source, "<test>").unwrap();
@ -654,7 +654,7 @@ class Foo(A, B):
}
#[test]
#[cfg(not(feature = "all-nodes-with-ranges"))]
#[cfg(feature = "all-nodes-with-ranges")]
fn test_parse_double_list_comprehension() {
let source = "[x for y, y2 in z for a in b if a < 5 if a > 10]";
let parse_ast = ast::Expr::parse(source, "<test>").unwrap();
@ -662,7 +662,7 @@ class Foo(A, B):
}
#[test]
#[cfg(not(feature = "all-nodes-with-ranges"))]
#[cfg(feature = "all-nodes-with-ranges")]
fn test_parse_generator_comprehension() {
let source = "(x for y in z)";
let parse_ast = ast::Expr::parse(source, "<test>").unwrap();
@ -670,7 +670,7 @@ class Foo(A, B):
}
#[test]
#[cfg(not(feature = "all-nodes-with-ranges"))]
#[cfg(feature = "all-nodes-with-ranges")]
fn test_parse_named_expression_generator_comprehension() {
let source = "(x := y + 1 for y in z)";
let parse_ast = ast::Expr::parse(source, "<test>").unwrap();
@ -678,7 +678,7 @@ class Foo(A, B):
}
#[test]
#[cfg(not(feature = "all-nodes-with-ranges"))]
#[cfg(feature = "all-nodes-with-ranges")]
fn test_parse_if_else_generator_comprehension() {
let source = "(x if y else y for y in z)";
let parse_ast = ast::Expr::parse(source, "<test>").unwrap();
@ -707,7 +707,7 @@ class Foo(A, B):
}
#[test]
#[cfg(not(feature = "all-nodes-with-ranges"))]
#[cfg(feature = "all-nodes-with-ranges")]
fn test_with_statement() {
let source = "\
with 0: pass
@ -777,7 +777,7 @@ array[3:5, *indexes_to_select]
}
#[test]
#[cfg(not(feature = "all-nodes-with-ranges"))]
#[cfg(feature = "all-nodes-with-ranges")]
fn test_generator_expression_argument() {
let source = r#"' '.join(
sql
@ -837,7 +837,7 @@ except* OSError as e:
}
#[test]
#[cfg(not(feature = "all-nodes-with-ranges"))]
#[cfg(feature = "all-nodes-with-ranges")]
fn test_match_as_identifier() {
let parse_ast = ast::Suite::parse(
r#"
@ -870,7 +870,7 @@ print(match(12))
}
#[test]
#[cfg(not(feature = "all-nodes-with-ranges"))]
#[cfg(feature = "all-nodes-with-ranges")]
fn test_patma() {
let source = r#"# Cases sampled from Lib/test/test_patma.py
@ -1042,7 +1042,7 @@ match w := x,:
}
#[test]
#[cfg(not(feature = "all-nodes-with-ranges"))]
#[cfg(feature = "all-nodes-with-ranges")]
fn test_match() {
let parse_ast = ast::Suite::parse(
r#"
@ -1073,7 +1073,7 @@ match x:
}
#[test]
#[cfg(not(feature = "all-nodes-with-ranges"))]
#[cfg(feature = "all-nodes-with-ranges")]
fn test_variadic_generics() {
let parse_ast = ast::Suite::parse(
r#"

136
parser/src/python.lalrpop
View file

@ -6,7 +6,7 @@
use crate::{
ast::{self as ast, Ranged},
lexer::{LexicalError, LexicalErrorType},
function::{ArgumentList, parse_args, parse_params, validate_arguments},
function::{ArgumentList, parse_args, validate_pos_params, validate_arguments},
context::set_context,
string::parse_strings,
token::{self, StringKind},
@ -979,18 +979,11 @@ FuncDef: ast::Stmt = {
},
};
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)
});
Parameters: ast::FunctionArguments = {
<location:@L> "(" <a: (ParameterList<TypedParameter, StarTypedParameter, DoubleStarTypedParameter>)?> ")" <end_location:@R> =>? {
a.as_ref().map(validate_arguments).transpose()?;
let args = a
.unwrap_or_else(|| ast::FunctionArguments::empty(optional_range(location, end_location)));
Ok(args)
}
@ -998,66 +991,59 @@ Parameters: ast::Arguments = {
// 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> =>? {
let (posonlyargs, args, defaults) = parse_params(param1)?;
ParameterList<ArgType, StarArgType, DoubleStarArgType>: ast::FunctionArguments = {
<location:@L> <param1:ParameterDefs<ArgType>> <args2:("," <ParameterListStarArgs<ArgType, StarArgType, DoubleStarArgType>>)?> ","? <end_location:@R> =>? {
validate_pos_params(&param1)?;
let (posonlyargs, args) = param1;
// Now gather rest of parameters:
let (vararg, kwonlyargs, kw_defaults, kwarg) = args2.unwrap_or((None, vec![], vec![], None));
let (vararg, kwonlyargs, kwarg) = args2.unwrap_or((None, vec![], None));
Ok(ast::Arguments {
Ok(ast::FunctionArguments {
posonlyargs,
args,
kwonlyargs,
vararg,
kwarg,
defaults,
kw_defaults,
range: optional_range(location, end_location)
})
},
<location:@L> <param1:ParameterDefs<ArgType>> <kw:("," <KwargParameter<ArgType>>)> ","? <end_location:@R> =>? {
let (posonlyargs, args, defaults) = parse_params(param1)?;
<location:@L> <param1:ParameterDefs<ArgType>> <kw:("," <KwargParameter<DoubleStarArgType>>)> ","? <end_location:@R> =>? {
validate_pos_params(&param1)?;
let (posonlyargs, args) = param1;
// Now gather rest of parameters:
let vararg = None;
let kwonlyargs = vec![];
let kw_defaults = vec![];
let kwarg = kw;
Ok(ast::Arguments {
Ok(ast::FunctionArguments {
posonlyargs,
args,
kwonlyargs,
vararg,
kwarg,
defaults,
kw_defaults,
range: optional_range(location, end_location)
})
},
<location:@L> <params:ParameterListStarArgs<ArgType, StarArgType>> ","? <end_location:@R> => {
let (vararg, kwonlyargs, kw_defaults, kwarg) = params;
ast::Arguments {
<location:@L> <params:ParameterListStarArgs<ArgType, StarArgType, DoubleStarArgType>> ","? <end_location:@R> => {
let (vararg, kwonlyargs, kwarg) = params;
ast::FunctionArguments {
posonlyargs: vec![],
args: vec![],
kwonlyargs,
vararg,
kwarg,
defaults: vec![],
kw_defaults,
range: optional_range(location, end_location)
}
},
<location:@L> <kwarg:KwargParameter<ArgType>> ","? <end_location:@R> => {
ast::Arguments {
<location:@L> <kwarg:KwargParameter<DoubleStarArgType>> ","? <end_location:@R> => {
ast::FunctionArguments {
posonlyargs: vec![],
args: vec![],
kwonlyargs: vec![],
vararg: None,
kwarg,
defaults: vec![],
kw_defaults: vec![],
range: optional_range(location, end_location)
}
},
@ -1065,34 +1051,51 @@ ParameterList<ArgType, StarArgType>: ast::Arguments = {
// Use inline here to make sure the "," is not creating an ambiguity.
#[inline]
ParameterDefs<ArgType>: (Vec<(ast::Arg, Option<ast::Expr>)>, Vec<(ast::Arg, Option<ast::Expr>)>) = {
ParameterDefs<ArgType>: (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>) = {
<args:OneOrMore<ParameterDef<ArgType>>> => {
(vec![], args)
},
<pos_args:OneOrMore<ParameterDef<ArgType>>> "," "/" <args:("," <ParameterDef<ArgType>>)*> => {
(pos_args, args)
<posonlyargs:OneOrMore<ParameterDef<ArgType>>> "," "/" <args:("," <ParameterDef<ArgType>>)*> => {
(posonlyargs, args)
},
};
ParameterDef<ArgType>: (ast::Arg, Option<ast::Expr>) = {
<i:ArgType> => (i, None),
<i:ArgType> "=" <e:Test<"all">> => (i, Some(e)),
ParameterDef<ArgType>: ast::ArgWithDefault = {
<i:ArgType> => i,
<mut i:ArgType> "=" <e:Test<"all">> => {
i.default = Some(Box::new(e));
i
},
};
UntypedParameter: ast::Arg = {
UntypedParameter: ast::ArgWithDefault = {
<location:@L> <arg:Identifier> <end_location:@R> => {
let def = ast::Arg { arg, annotation: None, type_comment: None, range: (location..end_location).into() };
ast::ArgWithDefault { def, default: None, range: optional_range(location, end_location) }
},
};
StarUntypedParameter: ast::Arg = {
<location:@L> <arg:Identifier> <end_location:@R> => ast::Arg { arg, annotation: None, type_comment: None, range: (location..end_location).into() },
};
TypedParameter: ast::Arg = {
TypedParameter: ast::ArgWithDefault = {
<location:@L> <arg:Identifier> <a:(":" <Test<"all">>)?> <end_location:@R> => {
let annotation = a.map(|x| Box::new(x));
ast::Arg { arg, annotation, type_comment: None, range: (location..end_location).into() }
let annotation = a.map(Box::new);
let def = ast::Arg { arg, annotation, type_comment: None, range: (location..end_location).into() };
ast::ArgWithDefault { def, default: None, range: optional_range(location, end_location) }
},
};
StarTypedParameter: ast::Arg = {
<location:@L> <arg:Identifier> <a:(":" <TestOrStarExpr>)?> <end_location:@R> => {
let annotation = a.map(|x| Box::new(x));
let annotation = a.map(Box::new);
ast::Arg { arg, annotation, type_comment: None, range: (location..end_location).into() }
},
};
DoubleStarTypedParameter: ast::Arg = {
<location:@L> <arg:Identifier> <a:(":" <Test<"all">>)?> <end_location:@R> => {
let annotation = a.map(Box::new);
ast::Arg { arg, annotation, type_comment: None, range: (location..end_location).into() }
},
};
@ -1100,23 +1103,9 @@ StarTypedParameter: ast::Arg = {
// Use inline here to make sure the "," is not creating an ambiguity.
// TODO: figure out another grammar that makes this inline no longer required.
#[inline]
ParameterListStarArgs<ArgType, StarArgType>: (Option<Box<ast::Arg>>, Vec<ast::Arg>, Vec<ast::Expr>, Option<Box<ast::Arg>>) = {
<location:@L> "*" <va:StarArgType?> <kw:("," <ParameterDef<ArgType>>)*> <kwarg:("," <KwargParameter<ArgType>>)?> =>? {
// Extract keyword arguments:
let mut kwonlyargs = Vec::new();
let mut kw_defaults = Vec::new();
let mut kwargs = Vec::with_capacity(kw.len());
for (name, value) in kw {
if let Some(value) = value {
kwonlyargs.push(name);
kw_defaults.push(value);
} else {
kwargs.push(name);
}
}
kwargs.extend(kwonlyargs.into_iter());
if va.is_none() && kwargs.is_empty() && kwarg.is_none() {
ParameterListStarArgs<ArgType, StarArgType, DoubleStarArgType>: (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>) = {
<location:@L> "*" <va:StarArgType?> <kwonlyargs:("," <ParameterDef<ArgType>>)*> <kwarg:("," <KwargParameter<DoubleStarArgType>>)?> =>? {
if va.is_none() && kwonlyargs.is_empty() && kwarg.is_none() {
Err(LexicalError {
error: LexicalErrorType::OtherError("named arguments must follow bare *".to_string()),
location,
@ -1126,7 +1115,7 @@ ParameterListStarArgs<ArgType, StarArgType>: (Option<Box<ast::Arg>>, Vec<ast::Ar
let kwarg = kwarg.flatten();
let va = va.map(Box::new);
Ok((va, kwargs, kw_defaults, kwarg))
Ok((va, kwonlyargs, kwarg))
}
};
@ -1205,21 +1194,10 @@ NamedExpression: ast::Expr = {
};
LambdaDef: ast::Expr = {
<location:@L> "lambda" <p:ParameterList<UntypedParameter, UntypedParameter>?> ":" <body:Test<"all">> <end_location:@R> =>? {
let p = validate_arguments(
p.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)
}
}
))?;
<location:@L> "lambda" <p:ParameterList<UntypedParameter, StarUntypedParameter, StarUntypedParameter>?> ":" <body:Test<"all">> <end_location:@R> =>? {
p.as_ref().map(validate_arguments).transpose()?;
let p = p
.unwrap_or_else(|| ast::FunctionArguments::empty(optional_range(location, end_location)));
Ok(ast::Expr::Lambda(
ast::ExprLambda {

43195
parser/src/python.rs generated
View file

File diff suppressed because it is too large Load diff

2
parser/src/snapshots/rustpython_parser__context__tests__assign_list_comp.snap generated
View file

@ -31,7 +31,7 @@ expression: parse_ast
),
generators: [
Comprehension {
range: (),
range: 7..25,
target: Name(
ExprName {
range: 11..12,

2
parser/src/snapshots/rustpython_parser__context__tests__assign_set_comp.snap generated
View file

@ -31,7 +31,7 @@ expression: parse_ast
),
generators: [
Comprehension {
range: (),
range: 7..25,
target: Name(
ExprName {
range: 11..12,

2
parser/src/snapshots/rustpython_parser__context__tests__assign_with.snap generated
View file

@ -8,7 +8,7 @@ expression: parse_ast
range: 0..17,
items: [
Withitem {
range: (),
range: 5..11,
context_expr: Constant(
ExprConstant {
range: 5..6,

54
parser/src/snapshots/rustpython_parser__function__tests__function_kw_only_args.snap generated
View file

@ -10,40 +10,50 @@ Ok(
name: Identifier(
"f",
),
args: Arguments {
range: (),
args: FunctionArguments {
range: 6..16,
posonlyargs: [],
args: [],
vararg: None,
kwonlyargs: [
Arg {
ArgWithDefault {
range: 9..10,
arg: Identifier(
"a",
),
annotation: None,
type_comment: None,
def: Arg {
range: 9..10,
arg: Identifier(
"a",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 12..13,
arg: Identifier(
"b",
),
annotation: None,
type_comment: None,
def: Arg {
range: 12..13,
arg: Identifier(
"b",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 15..16,
arg: Identifier(
"c",
),
annotation: None,
type_comment: None,
def: Arg {
range: 15..16,
arg: Identifier(
"c",
),
annotation: None,
type_comment: None,
},
default: None,
},
],
kw_defaults: [],
kwarg: None,
defaults: [],
},
body: [
Pass(

89
parser/src/snapshots/rustpython_parser__function__tests__function_kw_only_args_with_defaults.snap generated
View file

@ -10,59 +10,70 @@ Ok(
name: Identifier(
"f",
),
args: Arguments {
range: (),
args: FunctionArguments {
range: 6..22,
posonlyargs: [],
args: [],
vararg: None,
kwonlyargs: [
Arg {
ArgWithDefault {
range: 9..10,
arg: Identifier(
"a",
),
annotation: None,
type_comment: None,
def: Arg {
range: 9..10,
arg: Identifier(
"a",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 12..13,
arg: Identifier(
"b",
def: Arg {
range: 12..13,
arg: Identifier(
"b",
),
annotation: None,
type_comment: None,
},
default: Some(
Constant(
ExprConstant {
range: 14..16,
value: Int(
20,
),
kind: None,
},
),
),
annotation: None,
type_comment: None,
},
Arg {
ArgWithDefault {
range: 18..19,
arg: Identifier(
"c",
def: Arg {
range: 18..19,
arg: Identifier(
"c",
),
annotation: None,
type_comment: None,
},
default: Some(
Constant(
ExprConstant {
range: 20..22,
value: Int(
30,
),
kind: None,
},
),
),
annotation: None,
type_comment: None,
},
],
kw_defaults: [
Constant(
ExprConstant {
range: 14..16,
value: Int(
20,
),
kind: None,
},
),
Constant(
ExprConstant {
range: 20..22,
value: Int(
30,
),
kind: None,
},
),
],
kwarg: None,
defaults: [],
},
body: [
Pass(

6
parser/src/snapshots/rustpython_parser__function__tests__function_no_args.snap generated
View file

@ -10,15 +10,13 @@ Ok(
name: Identifier(
"f",
),
args: Arguments {
range: (),
args: FunctionArguments {
range: 5..7,
posonlyargs: [],
args: [],
vararg: None,
kwonlyargs: [],
kw_defaults: [],
kwarg: None,
defaults: [],
},
body: [
Pass(

102
parser/src/snapshots/rustpython_parser__function__tests__function_pos_and_kw_only_args.snap generated
View file

@ -10,65 +10,87 @@ Ok(
name: Identifier(
"f",
),
args: Arguments {
range: (),
args: FunctionArguments {
range: 6..25,
posonlyargs: [],
args: [
Arg {
ArgWithDefault {
range: 6..7,
arg: Identifier(
"a",
),
annotation: None,
type_comment: None,
def: Arg {
range: 6..7,
arg: Identifier(
"a",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 9..10,
arg: Identifier(
"b",
),
annotation: None,
type_comment: None,
def: Arg {
range: 9..10,
arg: Identifier(
"b",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 12..13,
arg: Identifier(
"c",
),
annotation: None,
type_comment: None,
def: Arg {
range: 12..13,
arg: Identifier(
"c",
),
annotation: None,
type_comment: None,
},
default: None,
},
],
vararg: None,
kwonlyargs: [
Arg {
ArgWithDefault {
range: 18..19,
arg: Identifier(
"d",
),
annotation: None,
type_comment: None,
def: Arg {
range: 18..19,
arg: Identifier(
"d",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 21..22,
arg: Identifier(
"e",
),
annotation: None,
type_comment: None,
def: Arg {
range: 21..22,
arg: Identifier(
"e",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 24..25,
arg: Identifier(
"f",
),
annotation: None,
type_comment: None,
def: Arg {
range: 24..25,
arg: Identifier(
"f",
),
annotation: None,
type_comment: None,
},
default: None,
},
],
kw_defaults: [],
kwarg: None,
defaults: [],
},
body: [
Pass(

137
parser/src/snapshots/rustpython_parser__function__tests__function_pos_and_kw_only_args_with_defaults.snap generated
View file

@ -10,84 +10,107 @@ Ok(
name: Identifier(
"f",
),
args: Arguments {
range: (),
args: FunctionArguments {
range: 6..31,
posonlyargs: [],
args: [
Arg {
ArgWithDefault {
range: 6..7,
arg: Identifier(
"a",
),
annotation: None,
type_comment: None,
def: Arg {
range: 6..7,
arg: Identifier(
"a",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 9..10,
arg: Identifier(
"b",
),
annotation: None,
type_comment: None,
def: Arg {
range: 9..10,
arg: Identifier(
"b",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 12..13,
arg: Identifier(
"c",
),
annotation: None,
type_comment: None,
def: Arg {
range: 12..13,
arg: Identifier(
"c",
),
annotation: None,
type_comment: None,
},
default: None,
},
],
vararg: None,
kwonlyargs: [
Arg {
ArgWithDefault {
range: 18..19,
arg: Identifier(
"d",
),
annotation: None,
type_comment: None,
def: Arg {
range: 18..19,
arg: Identifier(
"d",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 21..22,
arg: Identifier(
"e",
def: Arg {
range: 21..22,
arg: Identifier(
"e",
),
annotation: None,
type_comment: None,
},
default: Some(
Constant(
ExprConstant {
range: 23..25,
value: Int(
20,
),
kind: None,
},
),
),
annotation: None,
type_comment: None,
},
Arg {
ArgWithDefault {
range: 27..28,
arg: Identifier(
"f",
def: Arg {
range: 27..28,
arg: Identifier(
"f",
),
annotation: None,
type_comment: None,
},
default: Some(
Constant(
ExprConstant {
range: 29..31,
value: Int(
30,
),
kind: None,
},
),
),
annotation: None,
type_comment: None,
},
],
kw_defaults: [
Constant(
ExprConstant {
range: 23..25,
value: Int(
20,
),
kind: None,
},
),
Constant(
ExprConstant {
range: 29..31,
value: Int(
30,
),
kind: None,
},
),
],
kwarg: None,
defaults: [],
},
body: [
Pass(

137
parser/src/snapshots/rustpython_parser__function__tests__function_pos_and_kw_only_args_with_defaults_and_varargs.snap generated
View file

@ -10,33 +10,45 @@ Ok(
name: Identifier(
"f",
),
args: Arguments {
range: (),
args: FunctionArguments {
range: 6..35,
posonlyargs: [],
args: [
Arg {
ArgWithDefault {
range: 6..7,
arg: Identifier(
"a",
),
annotation: None,
type_comment: None,
def: Arg {
range: 6..7,
arg: Identifier(
"a",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 9..10,
arg: Identifier(
"b",
),
annotation: None,
type_comment: None,
def: Arg {
range: 9..10,
arg: Identifier(
"b",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 12..13,
arg: Identifier(
"c",
),
annotation: None,
type_comment: None,
def: Arg {
range: 12..13,
arg: Identifier(
"c",
),
annotation: None,
type_comment: None,
},
default: None,
},
],
vararg: Some(
@ -50,53 +62,64 @@ Ok(
},
),
kwonlyargs: [
Arg {
ArgWithDefault {
range: 22..23,
arg: Identifier(
"d",
),
annotation: None,
type_comment: None,
def: Arg {
range: 22..23,
arg: Identifier(
"d",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 25..26,
arg: Identifier(
"e",
def: Arg {
range: 25..26,
arg: Identifier(
"e",
),
annotation: None,
type_comment: None,
},
default: Some(
Constant(
ExprConstant {
range: 27..29,
value: Int(
20,
),
kind: None,
},
),
),
annotation: None,
type_comment: None,
},
Arg {
ArgWithDefault {
range: 31..32,
arg: Identifier(
"f",
def: Arg {
range: 31..32,
arg: Identifier(
"f",
),
annotation: None,
type_comment: None,
},
default: Some(
Constant(
ExprConstant {
range: 33..35,
value: Int(
30,
),
kind: None,
},
),
),
annotation: None,
type_comment: None,
},
],
kw_defaults: [
Constant(
ExprConstant {
range: 27..29,
value: Int(
20,
),
kind: None,
},
),
Constant(
ExprConstant {
range: 33..35,
value: Int(
30,
),
kind: None,
},
),
],
kwarg: None,
defaults: [],
},
body: [
Pass(

137
parser/src/snapshots/rustpython_parser__function__tests__function_pos_and_kw_only_args_with_defaults_and_varargs_and_kwargs.snap generated
View file

@ -10,33 +10,45 @@ Ok(
name: Identifier(
"f",
),
args: Arguments {
range: (),
args: FunctionArguments {
range: 6..45,
posonlyargs: [],
args: [
Arg {
ArgWithDefault {
range: 6..7,
arg: Identifier(
"a",
),
annotation: None,
type_comment: None,
def: Arg {
range: 6..7,
arg: Identifier(
"a",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 9..10,
arg: Identifier(
"b",
),
annotation: None,
type_comment: None,
def: Arg {
range: 9..10,
arg: Identifier(
"b",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 12..13,
arg: Identifier(
"c",
),
annotation: None,
type_comment: None,
def: Arg {
range: 12..13,
arg: Identifier(
"c",
),
annotation: None,
type_comment: None,
},
default: None,
},
],
vararg: Some(
@ -50,51 +62,63 @@ Ok(
},
),
kwonlyargs: [
Arg {
ArgWithDefault {
range: 22..23,
arg: Identifier(
"d",
),
annotation: None,
type_comment: None,
def: Arg {
range: 22..23,
arg: Identifier(
"d",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 25..26,
arg: Identifier(
"e",
def: Arg {
range: 25..26,
arg: Identifier(
"e",
),
annotation: None,
type_comment: None,
},
default: Some(
Constant(
ExprConstant {
range: 27..29,
value: Int(
20,
),
kind: None,
},
),
),
annotation: None,
type_comment: None,
},
Arg {
ArgWithDefault {
range: 31..32,
arg: Identifier(
"f",
def: Arg {
range: 31..32,
arg: Identifier(
"f",
),
annotation: None,
type_comment: None,
},
default: Some(
Constant(
ExprConstant {
range: 33..35,
value: Int(
30,
),
kind: None,
},
),
),
annotation: None,
type_comment: None,
},
],
kw_defaults: [
Constant(
ExprConstant {
range: 27..29,
value: Int(
20,
),
kind: None,
},
),
Constant(
ExprConstant {
range: 33..35,
value: Int(
30,
),
kind: None,
},
),
],
kwarg: Some(
Arg {
range: 39..45,
@ -105,7 +129,6 @@ Ok(
type_comment: None,
},
),
defaults: [],
},
body: [
Pass(

54
parser/src/snapshots/rustpython_parser__function__tests__function_pos_args.snap generated
View file

@ -10,40 +10,50 @@ Ok(
name: Identifier(
"f",
),
args: Arguments {
range: (),
args: FunctionArguments {
range: 6..13,
posonlyargs: [],
args: [
Arg {
ArgWithDefault {
range: 6..7,
arg: Identifier(
"a",
),
annotation: None,
type_comment: None,
def: Arg {
range: 6..7,
arg: Identifier(
"a",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 9..10,
arg: Identifier(
"b",
),
annotation: None,
type_comment: None,
def: Arg {
range: 9..10,
arg: Identifier(
"b",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 12..13,
arg: Identifier(
"c",
),
annotation: None,
type_comment: None,
def: Arg {
range: 12..13,
arg: Identifier(
"c",
),
annotation: None,
type_comment: None,
},
default: None,
},
],
vararg: None,
kwonlyargs: [],
kw_defaults: [],
kwarg: None,
defaults: [],
},
body: [
Pass(

89
parser/src/snapshots/rustpython_parser__function__tests__function_pos_args_with_defaults.snap generated
View file

@ -10,59 +10,70 @@ Ok(
name: Identifier(
"f",
),
args: Arguments {
range: (),
args: FunctionArguments {
range: 6..19,
posonlyargs: [],
args: [
Arg {
ArgWithDefault {
range: 6..7,
arg: Identifier(
"a",
),
annotation: None,
type_comment: None,
def: Arg {
range: 6..7,
arg: Identifier(
"a",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 9..10,
arg: Identifier(
"b",
def: Arg {
range: 9..10,
arg: Identifier(
"b",
),
annotation: None,
type_comment: None,
},
default: Some(
Constant(
ExprConstant {
range: 11..13,
value: Int(
20,
),
kind: None,
},
),
),
annotation: None,
type_comment: None,
},
Arg {
ArgWithDefault {
range: 15..16,
arg: Identifier(
"c",
def: Arg {
range: 15..16,
arg: Identifier(
"c",
),
annotation: None,
type_comment: None,
},
default: Some(
Constant(
ExprConstant {
range: 17..19,
value: Int(
30,
),
kind: None,
},
),
),
annotation: None,
type_comment: None,
},
],
vararg: None,
kwonlyargs: [],
kw_defaults: [],
kwarg: None,
defaults: [
Constant(
ExprConstant {
range: 11..13,
value: Int(
20,
),
kind: None,
},
),
Constant(
ExprConstant {
range: 17..19,
value: Int(
30,
),
kind: None,
},
),
],
},
body: [
Pass(

54
parser/src/snapshots/rustpython_parser__function__tests__lambda_kw_only_args.snap generated
View file

@ -10,40 +10,50 @@ Ok(
value: Lambda(
ExprLambda {
range: 0..20,
args: Arguments {
range: (),
args: FunctionArguments {
range: 7..17,
posonlyargs: [],
args: [],
vararg: None,
kwonlyargs: [
Arg {
ArgWithDefault {
range: 10..11,
arg: Identifier(
"a",
),
annotation: None,
type_comment: None,
def: Arg {
range: 10..11,
arg: Identifier(
"a",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 13..14,
arg: Identifier(
"b",
),
annotation: None,
type_comment: None,
def: Arg {
range: 13..14,
arg: Identifier(
"b",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 16..17,
arg: Identifier(
"c",
),
annotation: None,
type_comment: None,
def: Arg {
range: 16..17,
arg: Identifier(
"c",
),
annotation: None,
type_comment: None,
},
default: None,
},
],
kw_defaults: [],
kwarg: None,
defaults: [],
},
body: Constant(
ExprConstant {

89
parser/src/snapshots/rustpython_parser__function__tests__lambda_kw_only_args_with_defaults.snap generated
View file

@ -10,59 +10,70 @@ Ok(
value: Lambda(
ExprLambda {
range: 0..26,
args: Arguments {
range: (),
args: FunctionArguments {
range: 7..23,
posonlyargs: [],
args: [],
vararg: None,
kwonlyargs: [
Arg {
ArgWithDefault {
range: 10..11,
arg: Identifier(
"a",
),
annotation: None,
type_comment: None,
def: Arg {
range: 10..11,
arg: Identifier(
"a",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 13..14,
arg: Identifier(
"b",
def: Arg {
range: 13..14,
arg: Identifier(
"b",
),
annotation: None,
type_comment: None,
},
default: Some(
Constant(
ExprConstant {
range: 15..17,
value: Int(
20,
),
kind: None,
},
),
),
annotation: None,
type_comment: None,
},
Arg {
ArgWithDefault {
range: 19..20,
arg: Identifier(
"c",
def: Arg {
range: 19..20,
arg: Identifier(
"c",
),
annotation: None,
type_comment: None,
},
default: Some(
Constant(
ExprConstant {
range: 21..23,
value: Int(
30,
),
kind: None,
},
),
),
annotation: None,
type_comment: None,
},
],
kw_defaults: [
Constant(
ExprConstant {
range: 15..17,
value: Int(
20,
),
kind: None,
},
),
Constant(
ExprConstant {
range: 21..23,
value: Int(
30,
),
kind: None,
},
),
],
kwarg: None,
defaults: [],
},
body: Constant(
ExprConstant {

6
parser/src/snapshots/rustpython_parser__function__tests__lambda_no_args.snap generated
View file

@ -10,15 +10,13 @@ Ok(
value: Lambda(
ExprLambda {
range: 0..9,
args: Arguments {
range: (),
args: FunctionArguments {
range: 0..9,
posonlyargs: [],
args: [],
vararg: None,
kwonlyargs: [],
kw_defaults: [],
kwarg: None,
defaults: [],
},
body: Constant(
ExprConstant {

86
parser/src/snapshots/rustpython_parser__function__tests__lambda_pos_and_kw_only_args.snap generated
View file

@ -10,57 +10,75 @@ Ok(
value: Lambda(
ExprLambda {
range: 0..26,
args: Arguments {
range: (),
args: FunctionArguments {
range: 7..23,
posonlyargs: [],
args: [
Arg {
ArgWithDefault {
range: 7..8,
arg: Identifier(
"a",
),
annotation: None,
type_comment: None,
def: Arg {
range: 7..8,
arg: Identifier(
"a",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 10..11,
arg: Identifier(
"b",
),
annotation: None,
type_comment: None,
def: Arg {
range: 10..11,
arg: Identifier(
"b",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 13..14,
arg: Identifier(
"c",
),
annotation: None,
type_comment: None,
def: Arg {
range: 13..14,
arg: Identifier(
"c",
),
annotation: None,
type_comment: None,
},
default: None,
},
],
vararg: None,
kwonlyargs: [
Arg {
ArgWithDefault {
range: 19..20,
arg: Identifier(
"d",
),
annotation: None,
type_comment: None,
def: Arg {
range: 19..20,
arg: Identifier(
"d",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 22..23,
arg: Identifier(
"e",
),
annotation: None,
type_comment: None,
def: Arg {
range: 22..23,
arg: Identifier(
"e",
),
annotation: None,
type_comment: None,
},
default: None,
},
],
kw_defaults: [],
kwarg: None,
defaults: [],
},
body: Constant(
ExprConstant {

54
parser/src/snapshots/rustpython_parser__function__tests__lambda_pos_args.snap generated
View file

@ -10,40 +10,50 @@ Ok(
value: Lambda(
ExprLambda {
range: 0..17,
args: Arguments {
range: (),
args: FunctionArguments {
range: 7..14,
posonlyargs: [],
args: [
Arg {
ArgWithDefault {
range: 7..8,
arg: Identifier(
"a",
),
annotation: None,
type_comment: None,
def: Arg {
range: 7..8,
arg: Identifier(
"a",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 10..11,
arg: Identifier(
"b",
),
annotation: None,
type_comment: None,
def: Arg {
range: 10..11,
arg: Identifier(
"b",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 13..14,
arg: Identifier(
"c",
),
annotation: None,
type_comment: None,
def: Arg {
range: 13..14,
arg: Identifier(
"c",
),
annotation: None,
type_comment: None,
},
default: None,
},
],
vararg: None,
kwonlyargs: [],
kw_defaults: [],
kwarg: None,
defaults: [],
},
body: Constant(
ExprConstant {

89
parser/src/snapshots/rustpython_parser__function__tests__lambda_pos_args_with_defaults.snap generated
View file

@ -10,59 +10,70 @@ Ok(
value: Lambda(
ExprLambda {
range: 0..23,
args: Arguments {
range: (),
args: FunctionArguments {
range: 7..20,
posonlyargs: [],
args: [
Arg {
ArgWithDefault {
range: 7..8,
arg: Identifier(
"a",
),
annotation: None,
type_comment: None,
def: Arg {
range: 7..8,
arg: Identifier(
"a",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 10..11,
arg: Identifier(
"b",
def: Arg {
range: 10..11,
arg: Identifier(
"b",
),
annotation: None,
type_comment: None,
},
default: Some(
Constant(
ExprConstant {
range: 12..14,
value: Int(
20,
),
kind: None,
},
),
),
annotation: None,
type_comment: None,
},
Arg {
ArgWithDefault {
range: 16..17,
arg: Identifier(
"c",
def: Arg {
range: 16..17,
arg: Identifier(
"c",
),
annotation: None,
type_comment: None,
},
default: Some(
Constant(
ExprConstant {
range: 18..20,
value: Int(
30,
),
kind: None,
},
),
),
annotation: None,
type_comment: None,
},
],
vararg: None,
kwonlyargs: [],
kw_defaults: [],
kwarg: None,
defaults: [
Constant(
ExprConstant {
range: 12..14,
value: Int(
20,
),
kind: None,
},
),
Constant(
ExprConstant {
range: 18..20,
value: Int(
30,
),
kind: None,
},
),
],
},
body: Constant(
ExprConstant {

2
parser/src/snapshots/rustpython_parser__parser__tests__generator_expression_argument.snap generated
View file

@ -38,7 +38,7 @@ Call(
),
generators: [
Comprehension {
range: (),
range: 22..139,
target: Name(
ExprName {
range: 26..29,

10
parser/src/snapshots/rustpython_parser__parser__tests__match.snap generated
View file

@ -37,7 +37,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 24..74,
pattern: MatchMapping(
PatternMatchMapping {
range: 29..52,
@ -122,7 +122,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 103..178,
pattern: MatchMapping(
PatternMatchMapping {
range: 108..155,
@ -236,7 +236,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 191..219,
pattern: MatchSequence(
PatternMatchSequence {
range: 196..203,
@ -319,7 +319,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 232..260,
pattern: MatchSequence(
PatternMatchSequence {
range: 237..244,
@ -402,7 +402,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 273..298,
pattern: MatchSequence(
PatternMatchSequence {
range: 278..282,

26
parser/src/snapshots/rustpython_parser__parser__tests__match_as_identifier.snap generated
View file

@ -712,7 +712,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 544..557,
pattern: MatchValue(
PatternMatchValue {
range: 549..550,
@ -737,7 +737,7 @@ expression: parse_ast
],
},
MatchCase {
range: (),
range: 561..582,
pattern: MatchValue(
PatternMatchValue {
range: 566..567,
@ -781,24 +781,26 @@ expression: parse_ast
value: Lambda(
ExprLambda {
range: 590..618,
args: Arguments {
range: (),
args: FunctionArguments {
range: 597..602,
posonlyargs: [],
args: [
Arg {
ArgWithDefault {
range: 597..602,
arg: Identifier(
"query",
),
annotation: None,
type_comment: None,
def: Arg {
range: 597..602,
arg: Identifier(
"query",
),
annotation: None,
type_comment: None,
},
default: None,
},
],
vararg: None,
kwonlyargs: [],
kw_defaults: [],
kwarg: None,
defaults: [],
},
body: Compare(
ExprCompare {

78
parser/src/snapshots/rustpython_parser__parser__tests__parse_class.snap generated
View file

@ -37,24 +37,26 @@ expression: "parse_program(source, \"<test>\").unwrap()"
name: Identifier(
"__init__",
),
args: Arguments {
range: (),
args: FunctionArguments {
range: 31..35,
posonlyargs: [],
args: [
Arg {
ArgWithDefault {
range: 31..35,
arg: Identifier(
"self",
),
annotation: None,
type_comment: None,
def: Arg {
range: 31..35,
arg: Identifier(
"self",
),
annotation: None,
type_comment: None,
},
default: None,
},
],
vararg: None,
kwonlyargs: [],
kw_defaults: [],
kwarg: None,
defaults: [],
},
body: [
Pass(
@ -74,42 +76,48 @@ expression: "parse_program(source, \"<test>\").unwrap()"
name: Identifier(
"method_with_default",
),
args: Arguments {
range: (),
args: FunctionArguments {
range: 70..89,
posonlyargs: [],
args: [
Arg {
ArgWithDefault {
range: 70..74,
arg: Identifier(
"self",
),
annotation: None,
type_comment: None,
def: Arg {
range: 70..74,
arg: Identifier(
"self",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 76..79,
arg: Identifier(
"arg",
def: Arg {
range: 76..79,
arg: Identifier(
"arg",
),
annotation: None,
type_comment: None,
},
default: Some(
Constant(
ExprConstant {
range: 80..89,
value: Str(
"default",
),
kind: None,
},
),
),
annotation: None,
type_comment: None,
},
],
vararg: None,
kwonlyargs: [],
kw_defaults: [],
kwarg: None,
defaults: [
Constant(
ExprConstant {
range: 80..89,
value: Str(
"default",
),
kind: None,
},
),
],
},
body: [
Pass(

2
parser/src/snapshots/rustpython_parser__parser__tests__parse_dict_comprehension.snap generated
View file

@ -25,7 +25,7 @@ DictComp(
),
generators: [
Comprehension {
range: (),
range: 8..18,
target: Name(
ExprName {
range: 12..13,

4
parser/src/snapshots/rustpython_parser__parser__tests__parse_double_list_comprehension.snap generated
View file

@ -16,7 +16,7 @@ ListComp(
),
generators: [
Comprehension {
range: (),
range: 3..17,
target: Tuple(
ExprTuple {
range: 7..12,
@ -56,7 +56,7 @@ ListComp(
is_async: false,
},
Comprehension {
range: (),
range: 18..47,
target: Name(
ExprName {
range: 22..23,

2
parser/src/snapshots/rustpython_parser__parser__tests__parse_generator_comprehension.snap generated
View file

@ -16,7 +16,7 @@ GeneratorExp(
),
generators: [
Comprehension {
range: (),
range: 3..13,
target: Name(
ExprName {
range: 7..8,

2
parser/src/snapshots/rustpython_parser__parser__tests__parse_if_else_generator_comprehension.snap generated
View file

@ -39,7 +39,7 @@ GeneratorExp(
),
generators: [
Comprehension {
range: (),
range: 15..25,
target: Name(
ExprName {
range: 19..20,

38
parser/src/snapshots/rustpython_parser__parser__tests__parse_lambda.snap generated
View file

@ -9,32 +9,38 @@ expression: parse_ast
value: Lambda(
ExprLambda {
range: 0..18,
args: Arguments {
range: (),
args: FunctionArguments {
range: 7..11,
posonlyargs: [],
args: [
Arg {
ArgWithDefault {
range: 7..8,
arg: Identifier(
"x",
),
annotation: None,
type_comment: None,
def: Arg {
range: 7..8,
arg: Identifier(
"x",
),
annotation: None,
type_comment: None,
},
default: None,
},
Arg {
ArgWithDefault {
range: 10..11,
arg: Identifier(
"y",
),
annotation: None,
type_comment: None,
def: Arg {
range: 10..11,
arg: Identifier(
"y",
),
annotation: None,
type_comment: None,
},
default: None,
},
],
vararg: None,
kwonlyargs: [],
kw_defaults: [],
kwarg: None,
defaults: [],
},
body: BinOp(
ExprBinOp {

2
parser/src/snapshots/rustpython_parser__parser__tests__parse_list_comprehension.snap generated
View file

@ -16,7 +16,7 @@ ListComp(
),
generators: [
Comprehension {
range: (),
range: 3..13,
target: Name(
ExprName {
range: 7..8,

2
parser/src/snapshots/rustpython_parser__parser__tests__parse_named_expression_generator_comprehension.snap generated
View file

@ -45,7 +45,7 @@ GeneratorExp(
),
generators: [
Comprehension {
range: (),
range: 12..22,
target: Name(
ExprName {
range: 16..17,

94
parser/src/snapshots/rustpython_parser__parser__tests__patma.snap generated
View file

@ -17,7 +17,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 80..126,
pattern: MatchValue(
PatternMatchValue {
range: 85..88,
@ -86,7 +86,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 139..190,
pattern: MatchClass(
PatternMatchClass {
range: 144..152,
@ -163,7 +163,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 203..234,
pattern: MatchValue(
PatternMatchValue {
range: 208..209,
@ -219,7 +219,7 @@ expression: parse_ast
],
},
MatchCase {
range: (),
range: 234..283,
pattern: MatchValue(
PatternMatchValue {
range: 239..240,
@ -291,7 +291,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 296..355,
pattern: MatchOr(
PatternMatchOr {
range: 301..314,
@ -402,7 +402,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 368..445,
pattern: MatchOr(
PatternMatchOr {
range: 373..388,
@ -527,7 +527,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 458..494,
pattern: MatchSequence(
PatternMatchSequence {
range: 463..467,
@ -562,7 +562,7 @@ expression: parse_ast
],
},
MatchCase {
range: (),
range: 494..546,
pattern: MatchMapping(
PatternMatchMapping {
range: 499..501,
@ -608,7 +608,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 559..599,
pattern: MatchMapping(
PatternMatchMapping {
range: 564..579,
@ -702,7 +702,7 @@ expression: parse_ast
],
},
MatchCase {
range: (),
range: 599..692,
pattern: MatchOr(
PatternMatchOr {
range: 604..672,
@ -940,7 +940,7 @@ expression: parse_ast
],
},
MatchCase {
range: (),
range: 692..737,
pattern: MatchSequence(
PatternMatchSequence {
range: 697..699,
@ -994,7 +994,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 750..805,
pattern: MatchValue(
PatternMatchValue {
range: 755..767,
@ -1072,7 +1072,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 818..864,
pattern: MatchValue(
PatternMatchValue {
range: 823..826,
@ -1141,7 +1141,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 877..936,
pattern: MatchOr(
PatternMatchOr {
range: 882..895,
@ -1252,7 +1252,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 949..998,
pattern: MatchValue(
PatternMatchValue {
range: 954..955,
@ -1324,7 +1324,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 1011..1042,
pattern: MatchMapping(
PatternMatchMapping {
range: 1016..1022,
@ -1389,7 +1389,7 @@ expression: parse_ast
],
},
MatchCase {
range: (),
range: 1042..1073,
pattern: MatchMapping(
PatternMatchMapping {
range: 1047..1053,
@ -1454,7 +1454,7 @@ expression: parse_ast
],
},
MatchCase {
range: (),
range: 1073..1121,
pattern: MatchMapping(
PatternMatchMapping {
range: 1078..1083,
@ -1521,7 +1521,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 1138..1185,
pattern: MatchSequence(
PatternMatchSequence {
range: 1143..1147,
@ -1582,7 +1582,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 1198..1224,
pattern: MatchValue(
PatternMatchValue {
range: 1203..1204,
@ -1628,7 +1628,7 @@ expression: parse_ast
],
},
MatchCase {
range: (),
range: 1224..1268,
pattern: MatchValue(
PatternMatchValue {
range: 1229..1230,
@ -1690,7 +1690,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 1281..1338,
pattern: MatchMapping(
PatternMatchMapping {
range: 1286..1298,
@ -1794,7 +1794,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 1359..1415,
pattern: MatchSequence(
PatternMatchSequence {
range: 1364..1377,
@ -1901,7 +1901,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 1428..1456,
pattern: MatchSequence(
PatternMatchSequence {
range: 1433..1436,
@ -1954,7 +1954,7 @@ expression: parse_ast
],
},
MatchCase {
range: (),
range: 1456..1503,
pattern: MatchSequence(
PatternMatchSequence {
range: 1461..1467,
@ -2069,7 +2069,7 @@ expression: parse_ast
],
},
MatchCase {
range: (),
range: 1503..1552,
pattern: MatchSequence(
PatternMatchSequence {
range: 1508..1514,
@ -2152,7 +2152,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 1565..1618,
pattern: MatchSequence(
PatternMatchSequence {
range: 1570..1580,
@ -2235,7 +2235,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 1631..1687,
pattern: MatchValue(
PatternMatchValue {
range: 1636..1649,
@ -2327,7 +2327,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 1703..1749,
pattern: MatchSequence(
PatternMatchSequence {
range: 1708..1711,
@ -2393,7 +2393,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 1762..1812,
pattern: MatchValue(
PatternMatchValue {
range: 1767..1774,
@ -2482,7 +2482,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 1825..1872,
pattern: MatchSingleton(
PatternMatchSingleton {
range: 1830..1834,
@ -2536,7 +2536,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 1885..1929,
pattern: MatchValue(
PatternMatchValue {
range: 1890..1891,
@ -2598,7 +2598,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 1942..1990,
pattern: MatchSingleton(
PatternMatchSingleton {
range: 1947..1952,
@ -2654,7 +2654,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 2003..2030,
pattern: MatchSequence(
PatternMatchSequence {
range: 2008..2010,
@ -2692,7 +2692,7 @@ expression: parse_ast
],
},
MatchCase {
range: (),
range: 2030..2059,
pattern: MatchSequence(
PatternMatchSequence {
range: 2035..2039,
@ -2745,7 +2745,7 @@ expression: parse_ast
],
},
MatchCase {
range: (),
range: 2059..2104,
pattern: MatchValue(
PatternMatchValue {
range: 2064..2066,
@ -2807,7 +2807,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 2117..2161,
pattern: MatchAs(
PatternMatchAs {
range: 2122..2123,
@ -2866,7 +2866,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 2174..2230,
pattern: MatchSequence(
PatternMatchSequence {
range: 2179..2192,
@ -2953,7 +2953,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 2243..2330,
pattern: MatchOr(
PatternMatchOr {
range: 2248..2278,
@ -3130,7 +3130,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 2343..2383,
pattern: MatchMapping(
PatternMatchMapping {
range: 2348..2363,
@ -3224,7 +3224,7 @@ expression: parse_ast
],
},
MatchCase {
range: (),
range: 2383..2477,
pattern: MatchOr(
PatternMatchOr {
range: 2388..2457,
@ -3462,7 +3462,7 @@ expression: parse_ast
],
},
MatchCase {
range: (),
range: 2477..2522,
pattern: MatchSequence(
PatternMatchSequence {
range: 2482..2484,
@ -3542,7 +3542,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 2543..2591,
pattern: MatchSequence(
PatternMatchSequence {
range: 2548..2553,
@ -3647,7 +3647,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 2612..2661,
pattern: MatchSequence(
PatternMatchSequence {
range: 2617..2623,
@ -3726,7 +3726,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 2675..2720,
pattern: MatchSequence(
PatternMatchSequence {
range: 2680..2682,
@ -3809,7 +3809,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 2736..2783,
pattern: MatchSequence(
PatternMatchSequence {
range: 2741..2745,
@ -3900,7 +3900,7 @@ expression: parse_ast
),
cases: [
MatchCase {
range: (),
range: 2802..2830,
pattern: MatchSequence(
PatternMatchSequence {
range: 2807..2814,

6
parser/src/snapshots/rustpython_parser__parser__tests__variadic_generics.snap generated
View file

@ -9,8 +9,8 @@ expression: parse_ast
name: Identifier(
"args_to_tuple",
),
args: Arguments {
range: (),
args: FunctionArguments {
range: 19..29,
posonlyargs: [],
args: [],
vararg: Some(
@ -40,9 +40,7 @@ expression: parse_ast
},
),
kwonlyargs: [],
kw_defaults: [],
kwarg: None,
defaults: [],
},
body: [
Expr(

62
parser/src/snapshots/rustpython_parser__parser__tests__with_statement.snap generated
View file

@ -8,7 +8,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
range: 0..12,
items: [
Withitem {
range: (),
range: 5..6,
context_expr: Constant(
ExprConstant {
range: 5..6,
@ -36,7 +36,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
range: 13..30,
items: [
Withitem {
range: (),
range: 18..24,
context_expr: Constant(
ExprConstant {
range: 18..19,
@ -74,7 +74,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
range: 31..46,
items: [
Withitem {
range: (),
range: 36..37,
context_expr: Constant(
ExprConstant {
range: 36..37,
@ -87,7 +87,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
optional_vars: None,
},
Withitem {
range: (),
range: 39..40,
context_expr: Constant(
ExprConstant {
range: 39..40,
@ -115,7 +115,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
range: 47..72,
items: [
Withitem {
range: (),
range: 52..58,
context_expr: Constant(
ExprConstant {
range: 52..53,
@ -138,7 +138,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
),
},
Withitem {
range: (),
range: 60..66,
context_expr: Constant(
ExprConstant {
range: 60..61,
@ -176,7 +176,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
range: 73..97,
items: [
Withitem {
range: (),
range: 78..91,
context_expr: IfExp(
ExprIfExp {
range: 78..91,
@ -227,7 +227,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
range: 98..127,
items: [
Withitem {
range: (),
range: 103..121,
context_expr: IfExp(
ExprIfExp {
range: 103..116,
@ -288,7 +288,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
range: 128..141,
items: [
Withitem {
range: (),
range: 133..135,
context_expr: Tuple(
ExprTuple {
range: 133..135,
@ -314,7 +314,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
range: 142..160,
items: [
Withitem {
range: (),
range: 147..154,
context_expr: Tuple(
ExprTuple {
range: 147..149,
@ -350,7 +350,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
range: 161..175,
items: [
Withitem {
range: (),
range: 167..168,
context_expr: Constant(
ExprConstant {
range: 167..168,
@ -378,7 +378,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
range: 176..195,
items: [
Withitem {
range: (),
range: 181..189,
context_expr: Constant(
ExprConstant {
range: 182..183,
@ -416,7 +416,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
range: 196..211,
items: [
Withitem {
range: (),
range: 202..203,
context_expr: Constant(
ExprConstant {
range: 202..203,
@ -444,7 +444,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
range: 212..232,
items: [
Withitem {
range: (),
range: 217..226,
context_expr: Tuple(
ExprTuple {
range: 217..221,
@ -490,7 +490,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
range: 233..250,
items: [
Withitem {
range: (),
range: 239..243,
context_expr: Constant(
ExprConstant {
range: 239..240,
@ -503,7 +503,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
optional_vars: None,
},
Withitem {
range: (),
range: 239..243,
context_expr: Constant(
ExprConstant {
range: 242..243,
@ -531,7 +531,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
range: 251..273,
items: [
Withitem {
range: (),
range: 256..267,
context_expr: Tuple(
ExprTuple {
range: 256..262,
@ -586,7 +586,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
range: 274..290,
items: [
Withitem {
range: (),
range: 279..284,
context_expr: Tuple(
ExprTuple {
range: 279..284,
@ -628,7 +628,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
range: 291..312,
items: [
Withitem {
range: (),
range: 296..306,
context_expr: Tuple(
ExprTuple {
range: 296..301,
@ -680,7 +680,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
range: 313..331,
items: [
Withitem {
range: (),
range: 318..325,
context_expr: Tuple(
ExprTuple {
range: 318..325,
@ -731,7 +731,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
range: 332..355,
items: [
Withitem {
range: (),
range: 337..349,
context_expr: Tuple(
ExprTuple {
range: 337..344,
@ -792,7 +792,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
range: 356..375,
items: [
Withitem {
range: (),
range: 361..369,
context_expr: NamedExpr(
ExprNamedExpr {
range: 362..368,
@ -834,7 +834,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
range: 376..400,
items: [
Withitem {
range: (),
range: 381..394,
context_expr: NamedExpr(
ExprNamedExpr {
range: 382..388,
@ -886,7 +886,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
range: 401..428,
items: [
Withitem {
range: (),
range: 406..422,
context_expr: Tuple(
ExprTuple {
range: 406..422,
@ -959,7 +959,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
range: 429..461,
items: [
Withitem {
range: (),
range: 434..455,
context_expr: Tuple(
ExprTuple {
range: 434..450,
@ -1042,7 +1042,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
range: 462..481,
items: [
Withitem {
range: (),
range: 468..474,
context_expr: Constant(
ExprConstant {
range: 468..469,
@ -1080,7 +1080,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
range: 482..502,
items: [
Withitem {
range: (),
range: 488..494,
context_expr: Constant(
ExprConstant {
range: 488..489,
@ -1118,7 +1118,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
range: 503..530,
items: [
Withitem {
range: (),
range: 509..515,
context_expr: Constant(
ExprConstant {
range: 509..510,
@ -1141,7 +1141,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
),
},
Withitem {
range: (),
range: 517..523,
context_expr: Constant(
ExprConstant {
range: 517..518,
@ -1179,7 +1179,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
range: 531..559,
items: [
Withitem {
range: (),
range: 537..543,
context_expr: Constant(
ExprConstant {
range: 537..538,
@ -1202,7 +1202,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
),
},
Withitem {
range: (),
range: 545..551,
context_expr: Constant(
ExprConstant {
range: 545..546,