mirrors/RustPython-Parser
1
0
Fork 0
mirror of https://github.com/RustPython/Parser.git synced 2025-08-03 18:29:04 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

New Arguments and Arg/ArgWithDefault AST representation (#59)

Browse source
This commit is contained in:
Jeong, YunWon 2023-06-01 01:15:23 +09:00 • committed by GitHub
parent 3fbf4f6804
commit fdec727f80
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
51 changed files with 22648 additions and 21711 deletions
Download patch file Download diff file Expand all files Collapse all files

376
ast/asdl_rs.py
View file

@ -45,6 +45,74 @@ 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 each function argument that might have a default value.
Used by `Arguments` original type.
{ORIGINAL_NODE_WARNING}
""".strip()
alt_arguments = asdl.Type(
"alt: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),
]
),
)
alt_arguments.doc = f"""
An alternative type of AST `arguments`. This is parser-friendly and human-friendly definition of function arguments.
This form also has advantage to implement pre-order traverse.
`defaults` and `kw_defaults` fields are removed and the default values are placed under each `arg_with_default` typed argument.
`vararg` and `kwarg` are still typed as `arg` because they never can have a default value.
The matching Python style AST type is [PythonArguments]. While [PythonArguments] has ordered `kwonlyargs` fields by
default existence, [Arguments] has location-ordered kwonlyargs fields.
{ORIGINAL_NODE_WARNING}
""".strip()
# Must be used only for rust types, not python types
CUSTOM_TYPES = [
alt_arguments,
arg_with_default,
]
CUSTOM_REPLACEMENTS = {
"arguments": alt_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 +205,20 @@ 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]
@property
def is_custom_replaced(self):
return self.type.name in CUSTOM_REPLACEMENTS
@property
def custom(self):
if self.type.name in CUSTOM_REPLACEMENTS:
return CUSTOM_REPLACEMENTS[self.type.name]
return self.type
def no_cfg(self, typeinfo):
if self.is_product:
return self.has_attributes
@ -150,20 +232,26 @@ class TypeInfo:
return rust_type_name(self.name)
@property
def sum_name(self):
def full_field_name(self):
name = self.name
if name.startswith("alt:"):
name = name[4:]
if self.enum_name is None:
return self.name
return name
else:
return f"{self.enum_name}_{self.name}"
return f"{self.enum_name}_{rust_field_name(name)}"
@property
def rust_sum_name(self):
rust_name = rust_type_name(self.name)
if self.enum_name is None:
return rust_name
else:
name = rust_type_name(self.enum_name) + rust_name
return name
def full_type_name(self):
name = self.name
if name.startswith("alt:"):
name = name[4:]
rust_name = rust_type_name(name)
if self.enum_name is not None:
rust_name = rust_type_name(self.enum_name) + rust_name
if self.is_custom_replaced:
rust_name = "Python" + rust_name
return rust_name
def determine_user_data(self, type_info, stack):
if self.name in stack:
@ -184,6 +272,10 @@ class TypeInfo:
class TypeInfoMixin:
type_info: Dict[str, TypeInfo]
def customized_type_info(self, type_name):
info = self.type_info[type_name]
return self.type_info[info.custom.name]
def has_user_data(self, typ):
return self.type_info[typ].has_user_data
@ -223,18 +315,19 @@ 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():
info.determine_user_data(self.type_info, stack)
def visitType(self, type):
self.type_info[type.name] = TypeInfo(type)
self.visit(type.value, type)
key = type.name
info = self.type_info[key] = TypeInfo(type)
self.visit(type.value, info)
def visitSum(self, sum, type):
info = self.type_info[type.name]
def visitSum(self, sum, info):
type = info.type
info.is_simple = is_simple(sum)
for cons in sum.types:
self.visit(cons, type, info.is_simple)
@ -261,8 +354,8 @@ class FindUserDataTypesVisitor(asdl.VisitorBase):
info.enum_name = type.name
info.is_simple = simple
def visitProduct(self, product, type):
info = self.type_info[type.name]
def visitProduct(self, product, info):
type = info.type
if product.attributes:
# attributes means located, which has the `range: R` field
info.has_user_data = True
@ -308,7 +401,9 @@ class StructVisitor(EmitVisitor):
0,
)
for dfn in mod.dfns:
rust_name = rust_type_name(dfn.name)
info = self.customized_type_info(dfn.name)
dfn = info.custom
rust_name = info.full_type_name
generics = "" if self.type_info[dfn.name].is_simple else "<R>"
if dfn.name == "mod":
# This is exceptional rule to other enums.
@ -329,7 +424,8 @@ class StructVisitor(EmitVisitor):
0,
)
for dfn in mod.dfns:
rust_name = rust_type_name(dfn.name)
info = self.customized_type_info(dfn.name)
rust_name = info.full_type_name
generics = "" if self.type_info[dfn.name].is_simple else "<R>"
self.emit(
f"""
@ -342,10 +438,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 +591,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)
try:
field_type = self.customized_type_info(field.type)
typ = field_type.full_type_name
except KeyError:
field_type = None
typ = rust_type_name(field.type)
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>>>
@ -520,9 +623,8 @@ class StructVisitor(EmitVisitor):
def visitProduct(self, product, type, depth):
type_info = self.type_info[type.name]
product_name = rust_type_name(type.name)
product_name = type_info.full_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,19 +686,20 @@ 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)
def visitType(self, type, depth):
name = type.name
apply_u, apply_target_u = self.apply_generics(name, "U", "Self::TargetU")
enum_name = rust_type_name(name)
info = self.type_info[type.name]
apply_u, apply_target_u = self.apply_generics(info.name, "U", "Self::TargetU")
enum_name = info.full_type_name
self.emit(
f"fn fold_{name}(&mut self, node: {enum_name}{apply_u}) -> Result<{enum_name}{apply_target_u}, Self::Error> {{",
f"fn fold_{info.full_field_name}(&mut self, node: {enum_name}{apply_u}) -> Result<{enum_name}{apply_target_u}, Self::Error> {{",
depth,
)
self.emit(f"fold_{name}(self, node)", depth + 1)
self.emit(f"fold_{info.full_field_name}(self, node)", depth + 1)
self.emit("}", depth)
if isinstance(type.value, asdl.Sum) and not is_simple(type.value):
@ -604,9 +707,10 @@ class FoldTraitDefVisitor(EmitVisitor):
self.visit(cons, type, depth)
def visitConstructor(self, cons, type, depth):
info = self.type_info[type.name]
apply_u, apply_target_u = self.apply_generics(type.name, "U", "Self::TargetU")
enum_name = rust_type_name(type.name)
func_name = f"fold_{type.name}_{rust_field_name(cons.name)}"
func_name = f"fold_{info.full_field_name}_{rust_field_name(cons.name)}"
self.emit(
f"fn {func_name}(&mut self, node: {enum_name}{cons.name}{apply_u}) -> Result<{enum_name}{cons.name}{apply_target_u}, Self::Error> {{",
depth,
@ -617,7 +721,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):
@ -668,7 +773,8 @@ class FoldImplVisitor(EmitVisitor):
apply_t, apply_u, apply_target_u = self.apply_generics(
type.name, "T", "U", "F::TargetU"
)
enum_name = rust_type_name(type.name)
info = self.type_info[type.name]
enum_name = info.full_type_name
cons_type_name = f"{enum_name}{cons.name}"
@ -679,21 +785,20 @@ class FoldImplVisitor(EmitVisitor):
depth + 1,
)
self.emit(
f"folder.fold_{type.name}_{rust_field_name(cons.name)}(self)", depth + 2
f"folder.fold_{info.full_field_name}_{rust_field_name(cons.name)}(self)",
depth + 2,
)
self.emit("}", depth + 1)
self.emit("}", depth)
self.emit(
f"pub fn fold_{type.name}_{rust_field_name(cons.name)}<U, F: Fold<U> + ?Sized>(#[allow(unused)] folder: &mut F, node: {cons_type_name}{apply_u}) -> Result<{enum_name}{cons.name}{apply_target_u}, F::Error> {{",
f"pub fn fold_{info.full_field_name}_{rust_field_name(cons.name)}<U, F: Fold<U> + ?Sized>(#[allow(unused)] folder: &mut F, node: {cons_type_name}{apply_u}) -> Result<{enum_name}{cons.name}{apply_target_u}, F::Error> {{",
depth,
)
type_info = self.type_info[type.name]
fields_pattern = self.make_pattern(cons.fields)
map_user_suffix = "" if type_info.has_attributes else "_cfg"
map_user_suffix = "" if info.has_attributes else "_cfg"
self.emit(
f"""
let {cons_type_name} {{ {fields_pattern} }} = node;
@ -710,11 +815,12 @@ class FoldImplVisitor(EmitVisitor):
self.emit("}", depth + 2)
def visitProduct(self, product, type, depth):
info = self.type_info[type.name]
name = type.name
apply_t, apply_u, apply_target_u = self.apply_generics(
name, "T", "U", "F::TargetU"
)
struct_name = rust_type_name(name)
struct_name = info.full_type_name
has_attributes = bool(product.attributes)
self.emit(f"impl<T, U> Foldable<T, U> for {struct_name}{apply_t} {{", depth)
@ -723,12 +829,12 @@ class FoldImplVisitor(EmitVisitor):
"fn fold<F: Fold<T, TargetU = U> + ?Sized>(self, folder: &mut F) -> Result<Self::Mapped, F::Error> {",
depth + 1,
)
self.emit(f"folder.fold_{name}(self)", depth + 2)
self.emit(f"folder.fold_{info.full_field_name}(self)", depth + 2)
self.emit("}", depth + 1)
self.emit("}", depth)
self.emit(
f"pub fn fold_{name}<U, F: Fold<U> + ?Sized>(#[allow(unused)] folder: &mut F, node: {struct_name}{apply_u}) -> Result<{struct_name}{apply_target_u}, F::Error> {{",
f"pub fn fold_{info.full_field_name}<U, F: Fold<U> + ?Sized>(#[allow(unused)] folder: &mut F, node: {struct_name}{apply_u}) -> Result<{struct_name}{apply_target_u}, F::Error> {{",
depth,
)
@ -777,7 +883,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 +898,12 @@ 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:
dfn = self.customized_type_info(dfn.name).type
self.visit(dfn, depth + 1)
self.emit("}", depth)
@ -810,26 +918,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 +954,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 +964,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 +1019,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 +1053,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 +1075,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 +1086,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 +1097,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 +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 {{
match self {{
{sum_match_arms}
@ -1041,7 +1150,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 +1161,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
}}
@ -1086,11 +1195,13 @@ class ToPyo3AstVisitor(EmitVisitor):
self.visit(type.value, type)
def visitProduct(self, product, type):
rust_name = rust_type_name(type.name)
info = self.type_info[type.name]
rust_name = info.full_type_name
self.emit_to_pyo3_with_fields(product, type, rust_name)
def visitSum(self, sum, type):
rust_name = rust_type_name(type.name)
info = self.type_info[type.name]
rust_name = info.full_type_name
simple = is_simple(sum)
if is_simple(sum):
return
@ -1243,8 +1354,9 @@ class Pyo3StructVisitor(EmitVisitor):
def ref(self):
return "&" if self.borrow else ""
def emit_class(self, name, rust_name, simple, base="super::Ast"):
info = self.type_info[name]
def emit_class(self, info, simple, base="super::Ast"):
inner_name = info.full_type_name
rust_name = self.type_info[info.custom.name].full_type_name
if simple:
generics = ""
else:
@ -1255,23 +1367,24 @@ class Pyo3StructVisitor(EmitVisitor):
into = f"{rust_name}"
else:
subclass = ""
body = f"(pub {self.ref_def} ast::{rust_name}{generics})"
body = f"(pub {self.ref_def} ast::{inner_name}{generics})"
into = f"{rust_name}(node)"
self.emit(
f"""
#[pyclass(module="{self.module_name}", name="_{name}", extends={base}, frozen{subclass})]
#[pyclass(module="{self.module_name}", name="_{info.name}", extends={base}, frozen{subclass})]
#[derive(Clone, Debug)]
pub struct {rust_name} {body};
impl From<{self.ref_def} ast::{rust_name}{generics}> for {rust_name} {{
fn from({"" if body else "_"}node: {self.ref_def} ast::{rust_name}{generics}) -> Self {{
impl From<{self.ref_def} ast::{inner_name}{generics}> for {rust_name} {{
fn from({"" if body else "_"}node: {self.ref_def} ast::{inner_name}{generics}) -> Self {{
{into}
}}
}}
""",
0,
)
if subclass:
self.emit(
f"""
@ -1313,7 +1426,7 @@ class Pyo3StructVisitor(EmitVisitor):
)
if not subclass:
self.emit_wrapper(rust_name)
self.emit_wrapper(info)
def emit_getter(self, owner, type_name):
self.emit(
@ -1371,10 +1484,12 @@ class Pyo3StructVisitor(EmitVisitor):
0,
)
def emit_wrapper(self, rust_name):
def emit_wrapper(self, info):
inner_name = info.full_type_name
rust_name = self.type_info[info.custom.name].full_type_name
self.emit(
f"""
impl ToPyWrapper for ast::{rust_name}{self.generics} {{
impl ToPyWrapper for ast::{inner_name}{self.generics} {{
#[inline]
fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {{
Ok({rust_name}(self).to_object(py))
@ -1392,10 +1507,11 @@ class Pyo3StructVisitor(EmitVisitor):
self.visit(type.value, type, depth)
def visitSum(self, sum, type, depth=0):
info = self.type_info[type.name]
rust_name = rust_type_name(type.name)
simple = is_simple(sum)
self.emit_class(type.name, rust_name, simple)
self.emit_class(info, simple)
if not simple:
self.emit(
@ -1424,8 +1540,9 @@ class Pyo3StructVisitor(EmitVisitor):
self.visit(cons, rust_name, simple, depth + 1)
def visitProduct(self, product, type, depth=0):
info = self.type_info[type.name]
rust_name = rust_type_name(type.name)
self.emit_class(type.name, rust_name, False)
self.emit_class(info, False)
if self.borrow:
self.emit_getter(product, rust_name)
@ -1448,9 +1565,9 @@ class Pyo3StructVisitor(EmitVisitor):
depth,
)
else:
info = self.type_info[cons.name]
self.emit_class(
cons.name,
f"{parent}{cons.name}",
info,
simple=False,
base=parent,
)
@ -1471,23 +1588,25 @@ class Pyo3PymoduleVisitor(EmitVisitor):
self.visit(type.value, type.name, depth)
def visitProduct(self, product, name, depth=0):
rust_name = rust_type_name(name)
self.emit_fields(name, rust_name, False)
info = self.type_info[name]
self.emit_fields(info, False)
def visitSum(self, sum, name, depth):
rust_name = rust_type_name(name)
info = self.type_info[name]
simple = is_simple(sum)
self.emit_fields(name, rust_name, True)
self.emit_fields(info, True)
for cons in sum.types:
self.visit(cons, name, simple, depth)
def visitConstructor(self, cons, parent, simple, depth):
rust_name = rust_type_name(parent) + rust_type_name(cons.name)
self.emit_fields(cons.name, rust_name, simple)
info = self.type_info[cons.name]
self.emit_fields(info, simple)
def emit_fields(self, name, rust_name, simple):
self.emit(f"super::init_type::<{rust_name}, ast::{rust_name}>(py, m)?;", 1)
def emit_fields(self, info, simple):
inner_name = info.full_type_name
rust_name = self.type_info[info.custom.name].full_type_name
self.emit(f"super::init_type::<{rust_name}, ast::{inner_name}>(py, m)?;", 1)
class StdlibClassDefVisitor(EmitVisitor):
@ -1499,7 +1618,9 @@ class StdlibClassDefVisitor(EmitVisitor):
self.visit(type.value, type.name, depth)
def visitSum(self, sum, name, depth):
struct_name = "Node" + rust_type_name(name)
# info = self.type_info[self.type_info[name].custom.name]
info = self.type_info[name]
struct_name = "Node" + info.full_type_name
self.emit(
f'#[pyclass(module = "_ast", name = {json.dumps(name)}, base = "NodeAst")]',
depth,
@ -1517,11 +1638,13 @@ class StdlibClassDefVisitor(EmitVisitor):
self.gen_class_def(name, product.fields, product.attributes, depth)
def gen_class_def(self, name, fields, attrs, depth, base=None):
info = self.type_info[self.type_info[name].custom.name]
if base is None:
base = "NodeAst"
struct_name = "Node" + rust_type_name(name)
struct_name = "Node" + info.full_type_name
else:
struct_name = base + rust_type_name(name)
struct_name = "Node" + info.full_type_name
self.emit(
f'#[pyclass(module = "_ast", name = {json.dumps(name)}, base = {json.dumps(base)})]',
depth,
@ -1596,11 +1719,9 @@ class StdlibTraitImplVisitor(EmitVisitor):
self.visit(type.value, type.name, depth)
def visitSum(self, sum, name, depth):
rust_name = rust_type_name(name)
info = self.type_info[name]
rust_name = info.full_type_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 +1765,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)
@ -1677,12 +1793,10 @@ class StdlibTraitImplVisitor(EmitVisitor):
self.emit("}", depth + 1)
def visitProduct(self, product, name, depth):
struct_name = rust_type_name(name)
info = self.type_info[name]
struct_name = info.full_type_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
@ -1826,8 +1940,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
def write(info: TypeInfo, rust_name: str):
if info.is_simple:
generics = ""
else:
@ -1845,8 +1958,14 @@ def write_pyo3_node(type_info, f):
""",
)
for info in type_info.values():
write(info)
for type_name, info in type_info.items():
rust_name = info.full_type_name
if info.is_custom:
if type_name != info.type.name:
rust_name = "Python" + rust_name
else:
continue
write(info, rust_name)
def write_to_pyo3(mod, type_info, f):
@ -1864,7 +1983,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 +1997,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} {{
@ -1903,20 +2024,21 @@ def write_pyo3_wrapper(mod, type_info, namespace, f):
Pyo3StructVisitor(namespace, f, type_info).visit(mod)
if namespace == "located":
for type_info in type_info.values():
if not type_info.is_simple or not type_info.is_sum:
for info in type_info.values():
if not info.is_simple or not info.is_sum:
continue
rust_name = type_info.rust_sum_name
rust_name = info.full_type_name
inner_name = type_info[info.custom.name].full_type_name
f.write(
f"""
impl ToPyWrapper for ast::{rust_name} {{
impl ToPyWrapper for ast::{inner_name} {{
#[inline]
fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {{
match &self {{
""",
)
for cons in type_info.type.value.types:
for cons in info.type.value.types:
f.write(
f"Self::{cons.name} => Ok({rust_name}{cons.name}.to_object(py)),",
)
@ -1928,7 +2050,7 @@ def write_pyo3_wrapper(mod, type_info, namespace, f):
""",
)
for cons in type_info.type.value.types:
for cons in info.type.value.types:
f.write(
f"""
impl ToPyWrapper for ast::{rust_name}{cons.name} {{
@ -1960,7 +2082,7 @@ def write_parse_def(mod, type_info, f):
cons_name = rust_type_name(info.name)
f.write(f"""
impl Parse for ast::{info.rust_sum_name} {{
impl Parse for ast::{info.full_type_name} {{
fn lex_starts_at(
source: &str,
offset: TextSize,

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

@ -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>;
@ -2368,9 +2374,7 @@ pub fn fold_arguments<U, F: Fold<U> + ?Sized>(
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 {
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,
})
}

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

@ -2679,7 +2679,7 @@ impl<R> Node for Excepthandler<R> {
}
#[derive(Clone, Debug, PartialEq)]
pub struct Arguments<R = TextRange> {
pub struct PythonArguments<R = TextRange> {
pub range: OptionalRange<R>,
pub posonlyargs: Vec<Arg<R>>,
pub args: Vec<Arg<R>>,
@ -2690,7 +2690,7 @@ pub struct Arguments<R = TextRange> {
pub defaults: Vec<Expr<R>>,
}
impl<R> Node for Arguments<R> {
impl<R> Node for PythonArguments<R> {
const NAME: &'static str = "arguments";
const FIELD_NAMES: &'static [&'static str] = &[
"posonlyargs",
@ -2987,3 +2987,46 @@ 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 and human-friendly definition of function arguments.
/// This form also has advantage to implement pre-order traverse.
/// `defaults` and `kw_defaults` fields are removed and the default values are placed under each `arg_with_default` typed argument.
/// `vararg` and `kwarg` are still typed as `arg` because they never can have a default value.
///
/// The matching Python style AST type is [PythonArguments]. While [PythonArguments] has ordered `kwonlyargs` fields by
/// default existence, [Arguments] has location-ordered kwonlyargs fields.
///
/// NOTE: This type is different from original Python AST.
#[derive(Clone, Debug, PartialEq)]
pub struct Arguments<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 Arguments<R> {
const NAME: &'static str = "alt:arguments";
const FIELD_NAMES: &'static [&'static str] =
&["posonlyargs", "args", "vararg", "kwonlyargs", "kwarg"];
}
/// An alternative type of AST `arg`. This is used for each function argument that might have a default value.
/// Used by `Arguments` 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"];
}

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

@ -660,11 +660,11 @@ impl Located for Excepthandler {
}
}
pub type Arguments = crate::generic::Arguments<SourceRange>;
pub type PythonArguments = crate::generic::PythonArguments<SourceRange>;
#[cfg(feature = "all-nodes-with-ranges")]
impl Located for Arguments {
impl Located for PythonArguments {
fn range(&self) -> SourceRange {
self.range
}
@ -815,3 +815,23 @@ impl Located for TypeIgnore {
}
}
}
pub type Arguments = crate::generic::Arguments<SourceRange>;
#[cfg(feature = "all-nodes-with-ranges")]
impl Located for Arguments {
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
}
}

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

@ -394,7 +394,7 @@ impl Ranged for crate::Excepthandler {
}
#[cfg(feature = "all-nodes-with-ranges")]
impl Ranged for crate::generic::Arguments<TextRange> {
impl Ranged for crate::generic::PythonArguments<TextRange> {
fn range(&self) -> TextRange {
self.range
}
@ -495,3 +495,16 @@ impl Ranged for crate::TypeIgnore {
}
}
}
#[cfg(feature = "all-nodes-with-ranges")]
impl Ranged for crate::generic::Arguments<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
}
}

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

@ -1,45 +1,45 @@
// 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);
@ -54,10 +54,10 @@ 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);
@ -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,19 +409,19 @@ 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);
@ -431,10 +431,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
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,22 +790,22 @@ 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);
}

262
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,257 @@ impl Cmpop {
}
}
impl<R> Arguments<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,
{
let range = {
if cfg!(feature = "all-nodes-with-ranges") {
todo!("range recovery is not implemented yet") // def.range.start()..default.range.end()
} else {
#[allow(clippy::useless_conversion)] // false positive by cfg
OptionalRange::from(def.range.clone())
}
};
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> Arguments<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_python_arguments(&self) -> PythonArguments<R>
where
R: Clone,
{
let Arguments {
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);
}
PythonArguments {
range: range.clone(),
posonlyargs: pos_only,
args: pos_args,
defaults,
vararg: vararg.clone(),
kwonlyargs: kw_only,
kw_defaults,
kwarg: kwarg.clone(),
}
}
pub fn into_python_arguments(self) -> PythonArguments<R> {
let Arguments {
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);
}
PythonArguments {
range,
posonlyargs: pos_only,
args: pos_args,
defaults,
vararg,
kwonlyargs: kw_only,
kw_defaults,
kwarg,
}
}
}
impl<R> PythonArguments<R> {
pub fn into_arguments(self) -> Arguments<R>
where
R: Clone,
{
let PythonArguments {
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);
}
Arguments {
range,
posonlyargs: pos_only,
args: pos_args,
vararg,
kwonlyargs: kw_only,
kwarg,
}
}
}
impl<R> From<Arguments<R>> for PythonArguments<R> {
fn from(arguments: Arguments<R>) -> Self {
arguments.into_python_arguments()
}
}
include!("gen/generic.rs");

9
ast/src/lib.rs
View file

@ -1,3 +1,12 @@
//! Python AST node definitions and utilities.
//!
//! AST nodes are very similary defined like [Python AST](https://docs.python.org/3/library/ast.html).
//! But a few exceptions exist due to parser optimization.
//! They can be transformed to matching Python-styled AST in reasonable cost.
//!
//! [PythonArguments] is replaced by [Arguments]. The new [Arguments] type representation uses a new type
//! [ArgWithDefault] to represent arguments with default values. See each type documentation for more details.
mod builtin;
mod generic;
mod impls;

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, ArgWithDefault, Arguments, Boolop, Comprehension, Constant, ConversionFlag, Expr,
Identifier, Operator, PythonArguments,
};
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_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_arguments<U>(&mut self, args: &Arguments<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_python_arguments<U>(&mut self, args: &PythonArguments<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() {