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

Move range from Attributed to Nodes

Browse source
This commit is contained in:
Micha Reiser 2023-05-11 16:28:10 +02:00
parent a983f4383f
commit ba0ae51e82
No known key found for this signature in database
117 changed files with 15349 additions and 13148 deletions
Download patch file Download diff file Expand all files Collapse all files

99
ast/asdl_rs.py
View file

@ -295,8 +295,6 @@ class StructVisitor(EmitVisitor):
# can just wrap it in Attributed<>
for t in sum.types:
if not t.fields:
continue
self.sum_subtype_struct(type_info, t, rust_name, depth)
generics, generics_applied = self.apply_generics(name, "U = ()", "U")
@ -310,13 +308,10 @@ class StructVisitor(EmitVisitor):
f'#[is(name = "{rust_field_name(t.name)}_{rust_name.lower()}")]',
depth + 1,
)
if t.fields:
(t_generics_applied,) = self.apply_generics(t.name, "U")
self.emit(
f"{t.name}({rust_name}{t.name}{t_generics_applied}),", depth + 1
)
else:
self.emit(f"{t.name},", depth + 1)
(t_generics_applied,) = self.apply_generics(t.name, "U")
self.emit(
f"{t.name}({rust_name}{t.name}{t_generics_applied}),", depth + 1
)
self.emit("}", depth)
if type_info.has_attributes:
self.emit(
@ -332,6 +327,7 @@ class StructVisitor(EmitVisitor):
self.emit(f"pub struct {payload_name}{generics} {{", depth)
for f in t.fields:
self.visit(f, sum_type_info, "pub ", depth + 1, t.name)
self.emit("pub range: TextRange", depth + 1)
self.emit("}", depth)
self.emit(
textwrap.dedent(
@ -346,6 +342,14 @@ class StructVisitor(EmitVisitor):
depth,
)
self.emit(f"impl{generics_applied} Ranged for {payload_name}{generics_applied} {{", depth)
self.emit("#[inline]", depth + 1)
self.emit("fn range(&self) -> TextRange {", depth + 1)
self.emit("self.range", depth + 2)
self.emit("}", depth + 1)
self.emit("}", depth)
self.emit("", depth)
def visitConstructor(self, cons, parent, depth):
if cons.fields:
self.emit(f"{cons.name} {{", depth)
@ -394,10 +398,22 @@ class StructVisitor(EmitVisitor):
data_def = f"{data_name}{generics}"
else:
data_def = data_name
generics_applied = ""
self.emit(f"pub struct {data_def} {{", depth)
for f in product.fields:
self.visit(f, type_info, "pub ", depth + 1)
self.emit("pub range: TextRange", depth + 1)
self.emit("}", depth)
self.emit(f"impl{generics_applied} Ranged for {data_name}{generics_applied} {{", depth)
self.emit("#[inline]", depth + 1)
self.emit("fn range(&self) -> TextRange {", depth + 1)
self.emit("self.range", depth + 2)
self.emit("}", depth + 1)
self.emit("}", depth)
self.emit("", depth)
if product.attributes:
# attributes should just be location info
if not has_expr:
@ -406,6 +422,7 @@ class StructVisitor(EmitVisitor):
f"pub type {rust_name}<U = ()> = Attributed<{data_name}{generics_applied}, U>;",
depth,
)
self.emit("", depth)
@ -420,9 +437,9 @@ class FoldTraitDefVisitor(EmitVisitor):
)
self.emit(
"""
fn map_attributed<T>(&mut self, attributed: Attributed<T, U>) -> Result<Attributed<T, Self::TargetU>, Self::Error> {
fn map_attributed<T>(&mut self, attributed: Attributed<T, U>) -> Result<Attributed<T, Self::TargetU>, Self::Error> where T: Ranged{
let custom = self.map_user(attributed.custom)?;
Ok(Attributed { range: attributed.range, custom, node: attributed.node })
Ok(Attributed { custom, node: attributed.node })
}""",
depth + 1,
)
@ -452,11 +469,11 @@ class FoldTraitDefVisitor(EmitVisitor):
class FoldImplVisitor(EmitVisitor):
def visitModule(self, mod, depth):
self.emit(
"fn fold_attributed<U, F: Fold<U> + ?Sized, T, MT>(folder: &mut F, node: Attributed<T, U>, f: impl FnOnce(&mut F, T) -> Result<MT, F::Error>) -> Result<Attributed<MT, F::TargetU>, F::Error> {",
"fn fold_attributed<U, F: Fold<U> + ?Sized, T, MT>(folder: &mut F, node: Attributed<T, U>, f: impl FnOnce(&mut F, T) -> Result<MT, F::Error>) -> Result<Attributed<MT, F::TargetU>, F::Error> where T: Ranged{",
depth,
)
self.emit(
"let node = folder.map_attributed(node)?; Ok(Attributed { custom: node.custom, range: node.range, node: f(folder, node.node)? })",
"let node = folder.map_attributed(node)?; Ok(Attributed { custom: node.custom, node: f(folder, node.node)? })",
depth + 1,
)
self.emit("}", depth)
@ -472,6 +489,7 @@ class FoldImplVisitor(EmitVisitor):
name, "T", "U", "F::TargetU"
)
enum_name = rust_type_name(name)
simple = is_simple(sum)
self.emit(f"impl<T, U> Foldable<T, U> for {enum_name}{apply_t} {{", depth)
self.emit(f"type Mapped = {enum_name}{apply_u};", depth + 1)
@ -493,14 +511,14 @@ class FoldImplVisitor(EmitVisitor):
self.emit("match node {", depth + 1)
for cons in sum.types:
fields_pattern = self.make_pattern(
enum_name, type_info.rust_suffix, cons.name, cons.fields
enum_name, type_info.rust_suffix, cons.name, cons.fields, simple
)
self.emit(
f"{fields_pattern[0]} {{ {fields_pattern[1]} }} {fields_pattern[2]} => {{",
f"{fields_pattern[0]} {{ {fields_pattern[1]}}} {fields_pattern[2]} => {{",
depth + 2,
)
self.gen_construction(
fields_pattern[0], cons.fields, fields_pattern[2], depth + 3
fields_pattern[0], cons.fields, fields_pattern[2], depth + 3, simple
)
self.emit("}", depth + 2)
self.emit("}", depth + 1)
@ -534,15 +552,15 @@ class FoldImplVisitor(EmitVisitor):
rust_name = struct_name + "Data"
else:
rust_name = struct_name
fields_pattern = self.make_pattern(rust_name, struct_name, None, product.fields)
fields_pattern = self.make_pattern(rust_name, struct_name, None, product.fields, False)
self.emit(f"let {rust_name} {{ {fields_pattern[1]} }} = node;", depth + 1)
self.gen_construction(rust_name, product.fields, "", depth + 1)
self.gen_construction(rust_name, product.fields, "", depth + 1, False)
if has_attributes:
self.emit("})", depth)
self.emit("}", depth)
def make_pattern(self, rust_name, suffix, fieldname, fields):
if fields:
def make_pattern(self, rust_name, suffix, fieldname: str, fields, simple_sum: bool):
if fields or not simple_sum:
header = f"{rust_name}{suffix}::{fieldname}({rust_name}{fieldname}"
footer = ")"
else:
@ -550,13 +568,20 @@ class FoldImplVisitor(EmitVisitor):
footer = ""
body = ",".join(rust_field(f.name) for f in fields)
if not simple_sum:
body = f"range, {body}"
return header, body, footer
def gen_construction(self, header, fields, footer, depth):
def gen_construction(self, header, fields, footer, depth, simple_sum: bool):
self.emit(f"Ok({header} {{", depth)
for field in fields:
name = rust_field(field.name)
self.emit(f"{name}: Foldable::fold({name}, folder)?,", depth + 1)
if not simple_sum:
self.emit("range", depth + 1)
self.emit(f"}}{footer})", depth)
@ -595,16 +620,13 @@ class VisitorTraitDefVisitor(StructVisitor):
def emit_visitor(self, nodename, depth, has_node=True):
type_info = self.type_info[nodename]
if has_node:
node_type = type_info.rust_sum_name
node_value = "node"
else:
node_type = "()"
node_value = "()"
node_type = type_info.rust_sum_name
self.emit(
f"fn visit_{type_info.sum_name}(&mut self, node: {node_type}) {{", depth
)
self.emit(f"self.generic_visit_{type_info.sum_name}({node_value})", depth + 1)
if has_node:
self.emit(f"self.generic_visit_{type_info.sum_name}(node)", depth + 1)
self.emit("}", depth)
def emit_generic_visitor_signature(self, nodename, depth, has_node=True):
@ -628,16 +650,15 @@ class VisitorTraitDefVisitor(StructVisitor):
def visit_match_for_type(self, nodename, rust_name, type_, depth):
self.emit(f"{rust_name}::{type_.name}", depth)
if type_.fields:
self.emit("(data)", depth)
data = "data"
else:
data = "()"
self.emit(f"=> self.visit_{nodename}_{type_.name}({data}),", depth)
self.emit("(data)", depth)
self.emit(f"=> self.visit_{nodename}_{type_.name}(data),", depth)
def visit_sum_type(self, name, type_, depth):
self.emit_visitor(type_.name, depth, has_node=type_.fields)
self.emit_generic_visitor_signature(type_.name, depth, has_node=type_.fields)
if not type_.fields:
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)
@ -956,10 +977,18 @@ class ChainOfVisitors:
def write_ast_def(mod, type_info, f):
f.write("""
use crate::text_size::{TextRange};
use crate::Ranged;
""")
StructVisitor(f, type_info).visit(mod)
def write_fold_def(mod, type_info, f):
f.write("""
use crate::Ranged;
""")
FoldModuleVisitor(f, type_info).visit(mod)

23
ast/src/builtin.rs
View file

@ -1,7 +1,6 @@
//! `builtin_types` in asdl.py and Attributed
use num_bigint::BigInt;
use rustpython_parser_core::text_size::{TextRange, TextSize};
pub type String = std::string::String;
@ -207,7 +206,6 @@ impl std::fmt::Display for Constant {
#[derive(Clone, Debug, PartialEq)]
pub struct Attributed<T, U = ()> {
pub range: TextRange,
pub custom: U,
pub node: T,
}
@ -218,31 +216,12 @@ impl<T, U> Attributed<T, U> {
pub fn node(&self) -> &T {
&self.node
}
/// Returns the `range` of the node. The range offsets are absolute to the start of the document.
#[inline]
pub const fn range(&self) -> TextRange {
self.range
}
/// Returns the absolute start position of the node from the beginning of the document.
#[inline]
pub const fn start(&self) -> TextSize {
self.range.start()
}
/// Returns the absolute position at which the node ends in the source document.
#[inline]
pub const fn end(&self) -> TextSize {
self.range.end()
}
}
impl<T> Attributed<T, ()> {
/// Creates a new node that spans the position specified by `range`.
pub fn new(range: impl Into<TextRange>, node: impl Into<T>) -> Self {
pub fn new(node: impl Into<T>) -> Self {
Self {
range: range.into(),
custom: (),
node: node.into(),
}

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

@ -1,6 +1,7 @@
// File automatically generated by ast/asdl_rs.py.
use crate::fold_helpers::Foldable;
use crate::Ranged;
pub trait Fold<U> {
type TargetU;
type Error;
@ -9,10 +10,12 @@ pub trait Fold<U> {
fn map_attributed<T>(
&mut self,
attributed: Attributed<T, U>,
) -> Result<Attributed<T, Self::TargetU>, Self::Error> {
) -> Result<Attributed<T, Self::TargetU>, Self::Error>
where
T: Ranged,
{
let custom = self.map_user(attributed.custom)?;
Ok(Attributed {
range: attributed.range,
custom,
node: attributed.node,
})
@ -92,11 +95,13 @@ fn fold_attributed<U, F: Fold<U> + ?Sized, T, MT>(
folder: &mut F,
node: Attributed<T, U>,
f: impl FnOnce(&mut F, T) -> Result<MT, F::Error>,
) -> Result<Attributed<MT, F::TargetU>, F::Error> {
) -> Result<Attributed<MT, F::TargetU>, F::Error>
where
T: Ranged,
{
let node = folder.map_attributed(node)?;
Ok(Attributed {
custom: node.custom,
range: node.range,
node: f(folder, node.node)?,
})
}
@ -114,22 +119,32 @@ pub fn fold_mod<U, F: Fold<U> + ?Sized>(
node: Mod<U>,
) -> Result<Mod<F::TargetU>, F::Error> {
match node {
Mod::Module(ModModule { body, type_ignores }) => Ok(Mod::Module(ModModule {
Mod::Module(ModModule {
range,
body,
type_ignores,
}) => Ok(Mod::Module(ModModule {
body: Foldable::fold(body, folder)?,
type_ignores: Foldable::fold(type_ignores, folder)?,
range,
})),
Mod::Interactive(ModInteractive { body }) => Ok(Mod::Interactive(ModInteractive {
Mod::Interactive(ModInteractive { range, body }) => Ok(Mod::Interactive(ModInteractive {
body: Foldable::fold(body, folder)?,
range,
})),
Mod::Expression(ModExpression { body }) => Ok(Mod::Expression(ModExpression {
Mod::Expression(ModExpression { range, body }) => Ok(Mod::Expression(ModExpression {
body: Foldable::fold(body, folder)?,
range,
})),
Mod::FunctionType(ModFunctionType {
range,
argtypes,
returns,
}) => Ok(Mod::FunctionType(ModFunctionType {
argtypes: Foldable::fold(argtypes, folder)?,
returns: Foldable::fold(returns, folder)?,
range,
})),
Mod::FunctionType(ModFunctionType { argtypes, returns }) => {
Ok(Mod::FunctionType(ModFunctionType {
argtypes: Foldable::fold(argtypes, folder)?,
returns: Foldable::fold(returns, folder)?,
}))
}
}
}
impl<T, U> Foldable<T, U> for Stmt<T> {
@ -147,6 +162,7 @@ pub fn fold_stmt<U, F: Fold<U> + ?Sized>(
) -> Result<Stmt<F::TargetU>, F::Error> {
fold_attributed(folder, node, |folder, node| match node {
StmtKind::FunctionDef(StmtFunctionDef {
range,
name,
args,
body,
@ -160,8 +176,10 @@ pub fn fold_stmt<U, F: Fold<U> + ?Sized>(
decorator_list: Foldable::fold(decorator_list, folder)?,
returns: Foldable::fold(returns, folder)?,
type_comment: Foldable::fold(type_comment, folder)?,
range,
})),
StmtKind::AsyncFunctionDef(StmtAsyncFunctionDef {
range,
name,
args,
body,
@ -175,8 +193,10 @@ pub fn fold_stmt<U, F: Fold<U> + ?Sized>(
decorator_list: Foldable::fold(decorator_list, folder)?,
returns: Foldable::fold(returns, folder)?,
type_comment: Foldable::fold(type_comment, folder)?,
range,
})),
StmtKind::ClassDef(StmtClassDef {
range,
name,
bases,
keywords,
@ -188,14 +208,18 @@ pub fn fold_stmt<U, F: Fold<U> + ?Sized>(
keywords: Foldable::fold(keywords, folder)?,
body: Foldable::fold(body, folder)?,
decorator_list: Foldable::fold(decorator_list, folder)?,
range,
})),
StmtKind::Return(StmtReturn { value }) => Ok(StmtKind::Return(StmtReturn {
StmtKind::Return(StmtReturn { range, value }) => Ok(StmtKind::Return(StmtReturn {
value: Foldable::fold(value, folder)?,
range,
})),
StmtKind::Delete(StmtDelete { targets }) => Ok(StmtKind::Delete(StmtDelete {
StmtKind::Delete(StmtDelete { range, targets }) => Ok(StmtKind::Delete(StmtDelete {
targets: Foldable::fold(targets, folder)?,
range,
})),
StmtKind::Assign(StmtAssign {
range,
targets,
value,
type_comment,
@ -203,15 +227,21 @@ pub fn fold_stmt<U, F: Fold<U> + ?Sized>(
targets: Foldable::fold(targets, folder)?,
value: Foldable::fold(value, folder)?,
type_comment: Foldable::fold(type_comment, folder)?,
range,
})),
StmtKind::AugAssign(StmtAugAssign {
range,
target,
op,
value,
}) => Ok(StmtKind::AugAssign(StmtAugAssign {
target: Foldable::fold(target, folder)?,
op: Foldable::fold(op, folder)?,
value: Foldable::fold(value, folder)?,
range,
})),
StmtKind::AugAssign(StmtAugAssign { target, op, value }) => {
Ok(StmtKind::AugAssign(StmtAugAssign {
target: Foldable::fold(target, folder)?,
op: Foldable::fold(op, folder)?,
value: Foldable::fold(value, folder)?,
}))
}
StmtKind::AnnAssign(StmtAnnAssign {
range,
target,
annotation,
value,
@ -221,8 +251,10 @@ pub fn fold_stmt<U, F: Fold<U> + ?Sized>(
annotation: Foldable::fold(annotation, folder)?,
value: Foldable::fold(value, folder)?,
simple: Foldable::fold(simple, folder)?,
range,
})),
StmtKind::For(StmtFor {
range,
target,
iter,
body,
@ -234,8 +266,10 @@ pub fn fold_stmt<U, F: Fold<U> + ?Sized>(
body: Foldable::fold(body, folder)?,
orelse: Foldable::fold(orelse, folder)?,
type_comment: Foldable::fold(type_comment, folder)?,
range,
})),
StmtKind::AsyncFor(StmtAsyncFor {
range,
target,
iter,
body,
@ -247,18 +281,32 @@ pub fn fold_stmt<U, F: Fold<U> + ?Sized>(
body: Foldable::fold(body, folder)?,
orelse: Foldable::fold(orelse, folder)?,
type_comment: Foldable::fold(type_comment, folder)?,
range,
})),
StmtKind::While(StmtWhile { test, body, orelse }) => Ok(StmtKind::While(StmtWhile {
StmtKind::While(StmtWhile {
range,
test,
body,
orelse,
}) => Ok(StmtKind::While(StmtWhile {
test: Foldable::fold(test, folder)?,
body: Foldable::fold(body, folder)?,
orelse: Foldable::fold(orelse, folder)?,
range,
})),
StmtKind::If(StmtIf { test, body, orelse }) => Ok(StmtKind::If(StmtIf {
StmtKind::If(StmtIf {
range,
test,
body,
orelse,
}) => Ok(StmtKind::If(StmtIf {
test: Foldable::fold(test, folder)?,
body: Foldable::fold(body, folder)?,
orelse: Foldable::fold(orelse, folder)?,
range,
})),
StmtKind::With(StmtWith {
range,
items,
body,
type_comment,
@ -266,8 +314,10 @@ pub fn fold_stmt<U, F: Fold<U> + ?Sized>(
items: Foldable::fold(items, folder)?,
body: Foldable::fold(body, folder)?,
type_comment: Foldable::fold(type_comment, folder)?,
range,
})),
StmtKind::AsyncWith(StmtAsyncWith {
range,
items,
body,
type_comment,
@ -275,16 +325,24 @@ pub fn fold_stmt<U, F: Fold<U> + ?Sized>(
items: Foldable::fold(items, folder)?,
body: Foldable::fold(body, folder)?,
type_comment: Foldable::fold(type_comment, folder)?,
range,
})),
StmtKind::Match(StmtMatch { subject, cases }) => Ok(StmtKind::Match(StmtMatch {
StmtKind::Match(StmtMatch {
range,
subject,
cases,
}) => Ok(StmtKind::Match(StmtMatch {
subject: Foldable::fold(subject, folder)?,
cases: Foldable::fold(cases, folder)?,
range,
})),
StmtKind::Raise(StmtRaise { exc, cause }) => Ok(StmtKind::Raise(StmtRaise {
StmtKind::Raise(StmtRaise { range, exc, cause }) => Ok(StmtKind::Raise(StmtRaise {
exc: Foldable::fold(exc, folder)?,
cause: Foldable::fold(cause, folder)?,
range,
})),
StmtKind::Try(StmtTry {
range,
body,
handlers,
orelse,
@ -294,8 +352,10 @@ pub fn fold_stmt<U, F: Fold<U> + ?Sized>(
handlers: Foldable::fold(handlers, folder)?,
orelse: Foldable::fold(orelse, folder)?,
finalbody: Foldable::fold(finalbody, folder)?,
range,
})),
StmtKind::TryStar(StmtTryStar {
range,
body,
handlers,
orelse,
@ -305,15 +365,19 @@ pub fn fold_stmt<U, F: Fold<U> + ?Sized>(
handlers: Foldable::fold(handlers, folder)?,
orelse: Foldable::fold(orelse, folder)?,
finalbody: Foldable::fold(finalbody, folder)?,
range,
})),
StmtKind::Assert(StmtAssert { test, msg }) => Ok(StmtKind::Assert(StmtAssert {
StmtKind::Assert(StmtAssert { range, test, msg }) => Ok(StmtKind::Assert(StmtAssert {
test: Foldable::fold(test, folder)?,
msg: Foldable::fold(msg, folder)?,
range,
})),
StmtKind::Import(StmtImport { names }) => Ok(StmtKind::Import(StmtImport {
StmtKind::Import(StmtImport { range, names }) => Ok(StmtKind::Import(StmtImport {
names: Foldable::fold(names, folder)?,
range,
})),
StmtKind::ImportFrom(StmtImportFrom {
range,
module,
names,
level,
@ -321,19 +385,25 @@ pub fn fold_stmt<U, F: Fold<U> + ?Sized>(
module: Foldable::fold(module, folder)?,
names: Foldable::fold(names, folder)?,
level: Foldable::fold(level, folder)?,
range,
})),
StmtKind::Global(StmtGlobal { names }) => Ok(StmtKind::Global(StmtGlobal {
StmtKind::Global(StmtGlobal { range, names }) => Ok(StmtKind::Global(StmtGlobal {
names: Foldable::fold(names, folder)?,
range,
})),
StmtKind::Nonlocal(StmtNonlocal { names }) => Ok(StmtKind::Nonlocal(StmtNonlocal {
StmtKind::Nonlocal(StmtNonlocal { range, names }) => Ok(StmtKind::Nonlocal(StmtNonlocal {
names: Foldable::fold(names, folder)?,
range,
})),
StmtKind::Expr(StmtExpr { value }) => Ok(StmtKind::Expr(StmtExpr {
StmtKind::Expr(StmtExpr { range, value }) => Ok(StmtKind::Expr(StmtExpr {
value: Foldable::fold(value, folder)?,
range,
})),
StmtKind::Pass {} => Ok(StmtKind::Pass {}),
StmtKind::Break {} => Ok(StmtKind::Break {}),
StmtKind::Continue {} => Ok(StmtKind::Continue {}),
StmtKind::Pass(StmtPass { range }) => Ok(StmtKind::Pass(StmtPass { range })),
StmtKind::Break(StmtBreak { range }) => Ok(StmtKind::Break(StmtBreak { range })),
StmtKind::Continue(StmtContinue { range }) => {
Ok(StmtKind::Continue(StmtContinue { range }))
}
})
}
impl<T, U> Foldable<T, U> for Expr<T> {
@ -350,52 +420,87 @@ pub fn fold_expr<U, F: Fold<U> + ?Sized>(
node: Expr<U>,
) -> Result<Expr<F::TargetU>, F::Error> {
fold_attributed(folder, node, |folder, node| match node {
ExprKind::BoolOp(ExprBoolOp { op, values }) => Ok(ExprKind::BoolOp(ExprBoolOp {
ExprKind::BoolOp(ExprBoolOp { range, op, values }) => Ok(ExprKind::BoolOp(ExprBoolOp {
op: Foldable::fold(op, folder)?,
values: Foldable::fold(values, folder)?,
range,
})),
ExprKind::NamedExpr(ExprNamedExpr { target, value }) => {
Ok(ExprKind::NamedExpr(ExprNamedExpr {
target: Foldable::fold(target, folder)?,
value: Foldable::fold(value, folder)?,
}))
}
ExprKind::BinOp(ExprBinOp { left, op, right }) => Ok(ExprKind::BinOp(ExprBinOp {
ExprKind::NamedExpr(ExprNamedExpr {
range,
target,
value,
}) => Ok(ExprKind::NamedExpr(ExprNamedExpr {
target: Foldable::fold(target, folder)?,
value: Foldable::fold(value, folder)?,
range,
})),
ExprKind::BinOp(ExprBinOp {
range,
left,
op,
right,
}) => Ok(ExprKind::BinOp(ExprBinOp {
left: Foldable::fold(left, folder)?,
op: Foldable::fold(op, folder)?,
right: Foldable::fold(right, folder)?,
range,
})),
ExprKind::UnaryOp(ExprUnaryOp { op, operand }) => Ok(ExprKind::UnaryOp(ExprUnaryOp {
op: Foldable::fold(op, folder)?,
operand: Foldable::fold(operand, folder)?,
})),
ExprKind::Lambda(ExprLambda { args, body }) => Ok(ExprKind::Lambda(ExprLambda {
ExprKind::UnaryOp(ExprUnaryOp { range, op, operand }) => {
Ok(ExprKind::UnaryOp(ExprUnaryOp {
op: Foldable::fold(op, folder)?,
operand: Foldable::fold(operand, folder)?,
range,
}))
}
ExprKind::Lambda(ExprLambda { range, args, body }) => Ok(ExprKind::Lambda(ExprLambda {
args: Foldable::fold(args, folder)?,
body: Foldable::fold(body, folder)?,
range,
})),
ExprKind::IfExp(ExprIfExp { test, body, orelse }) => Ok(ExprKind::IfExp(ExprIfExp {
ExprKind::IfExp(ExprIfExp {
range,
test,
body,
orelse,
}) => Ok(ExprKind::IfExp(ExprIfExp {
test: Foldable::fold(test, folder)?,
body: Foldable::fold(body, folder)?,
orelse: Foldable::fold(orelse, folder)?,
range,
})),
ExprKind::Dict(ExprDict { keys, values }) => Ok(ExprKind::Dict(ExprDict {
ExprKind::Dict(ExprDict {
range,
keys,
values,
}) => Ok(ExprKind::Dict(ExprDict {
keys: Foldable::fold(keys, folder)?,
values: Foldable::fold(values, folder)?,
range,
})),
ExprKind::Set(ExprSet { elts }) => Ok(ExprKind::Set(ExprSet {
ExprKind::Set(ExprSet { range, elts }) => Ok(ExprKind::Set(ExprSet {
elts: Foldable::fold(elts, folder)?,
range,
})),
ExprKind::ListComp(ExprListComp { elt, generators }) => {
Ok(ExprKind::ListComp(ExprListComp {
elt: Foldable::fold(elt, folder)?,
generators: Foldable::fold(generators, folder)?,
}))
}
ExprKind::SetComp(ExprSetComp { elt, generators }) => Ok(ExprKind::SetComp(ExprSetComp {
ExprKind::ListComp(ExprListComp {
range,
elt,
generators,
}) => Ok(ExprKind::ListComp(ExprListComp {
elt: Foldable::fold(elt, folder)?,
generators: Foldable::fold(generators, folder)?,
range,
})),
ExprKind::SetComp(ExprSetComp {
range,
elt,
generators,
}) => Ok(ExprKind::SetComp(ExprSetComp {
elt: Foldable::fold(elt, folder)?,
generators: Foldable::fold(generators, folder)?,
range,
})),
ExprKind::DictComp(ExprDictComp {
range,
key,
value,
generators,
@ -403,23 +508,33 @@ pub fn fold_expr<U, F: Fold<U> + ?Sized>(
key: Foldable::fold(key, folder)?,
value: Foldable::fold(value, folder)?,
generators: Foldable::fold(generators, folder)?,
range,
})),
ExprKind::GeneratorExp(ExprGeneratorExp { elt, generators }) => {
Ok(ExprKind::GeneratorExp(ExprGeneratorExp {
elt: Foldable::fold(elt, folder)?,
generators: Foldable::fold(generators, folder)?,
ExprKind::GeneratorExp(ExprGeneratorExp {
range,
elt,
generators,
}) => Ok(ExprKind::GeneratorExp(ExprGeneratorExp {
elt: Foldable::fold(elt, folder)?,
generators: Foldable::fold(generators, folder)?,
range,
})),
ExprKind::Await(ExprAwait { range, value }) => Ok(ExprKind::Await(ExprAwait {
value: Foldable::fold(value, folder)?,
range,
})),
ExprKind::Yield(ExprYield { range, value }) => Ok(ExprKind::Yield(ExprYield {
value: Foldable::fold(value, folder)?,
range,
})),
ExprKind::YieldFrom(ExprYieldFrom { range, value }) => {
Ok(ExprKind::YieldFrom(ExprYieldFrom {
value: Foldable::fold(value, folder)?,
range,
}))
}
ExprKind::Await(ExprAwait { value }) => Ok(ExprKind::Await(ExprAwait {
value: Foldable::fold(value, folder)?,
})),
ExprKind::Yield(ExprYield { value }) => Ok(ExprKind::Yield(ExprYield {
value: Foldable::fold(value, folder)?,
})),
ExprKind::YieldFrom(ExprYieldFrom { value }) => Ok(ExprKind::YieldFrom(ExprYieldFrom {
value: Foldable::fold(value, folder)?,
})),
ExprKind::Compare(ExprCompare {
range,
left,
ops,
comparators,
@ -427,8 +542,10 @@ pub fn fold_expr<U, F: Fold<U> + ?Sized>(
left: Foldable::fold(left, folder)?,
ops: Foldable::fold(ops, folder)?,
comparators: Foldable::fold(comparators, folder)?,
range,
})),
ExprKind::Call(ExprCall {
range,
func,
args,
keywords,
@ -436,8 +553,10 @@ pub fn fold_expr<U, F: Fold<U> + ?Sized>(
func: Foldable::fold(func, folder)?,
args: Foldable::fold(args, folder)?,
keywords: Foldable::fold(keywords, folder)?,
range,
})),
ExprKind::FormattedValue(ExprFormattedValue {
range,
value,
conversion,
format_spec,
@ -445,48 +564,75 @@ pub fn fold_expr<U, F: Fold<U> + ?Sized>(
value: Foldable::fold(value, folder)?,
conversion: Foldable::fold(conversion, folder)?,
format_spec: Foldable::fold(format_spec, folder)?,
range,
})),
ExprKind::JoinedStr(ExprJoinedStr { values }) => Ok(ExprKind::JoinedStr(ExprJoinedStr {
values: Foldable::fold(values, folder)?,
})),
ExprKind::Constant(ExprConstant { value, kind }) => Ok(ExprKind::Constant(ExprConstant {
value: Foldable::fold(value, folder)?,
kind: Foldable::fold(kind, folder)?,
})),
ExprKind::Attribute(ExprAttribute { value, attr, ctx }) => {
Ok(ExprKind::Attribute(ExprAttribute {
value: Foldable::fold(value, folder)?,
attr: Foldable::fold(attr, folder)?,
ctx: Foldable::fold(ctx, folder)?,
ExprKind::JoinedStr(ExprJoinedStr { range, values }) => {
Ok(ExprKind::JoinedStr(ExprJoinedStr {
values: Foldable::fold(values, folder)?,
range,
}))
}
ExprKind::Subscript(ExprSubscript { value, slice, ctx }) => {
Ok(ExprKind::Subscript(ExprSubscript {
ExprKind::Constant(ExprConstant { range, value, kind }) => {
Ok(ExprKind::Constant(ExprConstant {
value: Foldable::fold(value, folder)?,
slice: Foldable::fold(slice, folder)?,
ctx: Foldable::fold(ctx, folder)?,
kind: Foldable::fold(kind, folder)?,
range,
}))
}
ExprKind::Starred(ExprStarred { value, ctx }) => Ok(ExprKind::Starred(ExprStarred {
ExprKind::Attribute(ExprAttribute {
range,
value,
attr,
ctx,
}) => Ok(ExprKind::Attribute(ExprAttribute {
value: Foldable::fold(value, folder)?,
attr: Foldable::fold(attr, folder)?,
ctx: Foldable::fold(ctx, folder)?,
range,
})),
ExprKind::Name(ExprName { id, ctx }) => Ok(ExprKind::Name(ExprName {
ExprKind::Subscript(ExprSubscript {
range,
value,
slice,
ctx,
}) => Ok(ExprKind::Subscript(ExprSubscript {
value: Foldable::fold(value, folder)?,
slice: Foldable::fold(slice, folder)?,
ctx: Foldable::fold(ctx, folder)?,
range,
})),
ExprKind::Starred(ExprStarred { range, value, ctx }) => {
Ok(ExprKind::Starred(ExprStarred {
value: Foldable::fold(value, folder)?,
ctx: Foldable::fold(ctx, folder)?,
range,
}))
}
ExprKind::Name(ExprName { range, id, ctx }) => Ok(ExprKind::Name(ExprName {
id: Foldable::fold(id, folder)?,
ctx: Foldable::fold(ctx, folder)?,
range,
})),
ExprKind::List(ExprList { elts, ctx }) => Ok(ExprKind::List(ExprList {
ExprKind::List(ExprList { range, elts, ctx }) => Ok(ExprKind::List(ExprList {
elts: Foldable::fold(elts, folder)?,
ctx: Foldable::fold(ctx, folder)?,
range,
})),
ExprKind::Tuple(ExprTuple { elts, ctx }) => Ok(ExprKind::Tuple(ExprTuple {
ExprKind::Tuple(ExprTuple { range, elts, ctx }) => Ok(ExprKind::Tuple(ExprTuple {
elts: Foldable::fold(elts, folder)?,
ctx: Foldable::fold(ctx, folder)?,
range,
})),
ExprKind::Slice(ExprSlice { lower, upper, step }) => Ok(ExprKind::Slice(ExprSlice {
ExprKind::Slice(ExprSlice {
range,
lower,
upper,
step,
}) => Ok(ExprKind::Slice(ExprSlice {
lower: Foldable::fold(lower, folder)?,
upper: Foldable::fold(upper, folder)?,
step: Foldable::fold(step, folder)?,
range,
})),
})
}
@ -616,6 +762,7 @@ pub fn fold_comprehension<U, F: Fold<U> + ?Sized>(
node: Comprehension<U>,
) -> Result<Comprehension<F::TargetU>, F::Error> {
let Comprehension {
range,
target,
iter,
ifs,
@ -626,6 +773,7 @@ pub fn fold_comprehension<U, F: Fold<U> + ?Sized>(
iter: Foldable::fold(iter, folder)?,
ifs: Foldable::fold(ifs, folder)?,
is_async: Foldable::fold(is_async, folder)?,
range,
})
}
impl<T, U> Foldable<T, U> for Excepthandler<T> {
@ -642,13 +790,19 @@ pub fn fold_excepthandler<U, F: Fold<U> + ?Sized>(
node: Excepthandler<U>,
) -> Result<Excepthandler<F::TargetU>, F::Error> {
fold_attributed(folder, node, |folder, node| match node {
ExcepthandlerKind::ExceptHandler(ExcepthandlerExceptHandler { type_, name, body }) => Ok(
ExcepthandlerKind::ExceptHandler(ExcepthandlerExceptHandler {
ExcepthandlerKind::ExceptHandler(ExcepthandlerExceptHandler {
range,
type_,
name,
body,
}) => Ok(ExcepthandlerKind::ExceptHandler(
ExcepthandlerExceptHandler {
type_: Foldable::fold(type_, folder)?,
name: Foldable::fold(name, folder)?,
body: Foldable::fold(body, folder)?,
}),
),
range,
},
)),
})
}
impl<T, U> Foldable<T, U> for Arguments<T> {
@ -665,6 +819,7 @@ pub fn fold_arguments<U, F: Fold<U> + ?Sized>(
node: Arguments<U>,
) -> Result<Arguments<F::TargetU>, F::Error> {
let Arguments {
range,
posonlyargs,
args,
vararg,
@ -681,6 +836,7 @@ pub fn fold_arguments<U, F: Fold<U> + ?Sized>(
kw_defaults: Foldable::fold(kw_defaults, folder)?,
kwarg: Foldable::fold(kwarg, folder)?,
defaults: Foldable::fold(defaults, folder)?,
range,
})
}
impl<T, U> Foldable<T, U> for Arg<T> {
@ -698,6 +854,7 @@ pub fn fold_arg<U, F: Fold<U> + ?Sized>(
) -> Result<Arg<F::TargetU>, F::Error> {
fold_attributed(folder, node, |folder, node| {
let ArgData {
range,
arg,
annotation,
type_comment,
@ -706,6 +863,7 @@ pub fn fold_arg<U, F: Fold<U> + ?Sized>(
arg: Foldable::fold(arg, folder)?,
annotation: Foldable::fold(annotation, folder)?,
type_comment: Foldable::fold(type_comment, folder)?,
range,
})
})
}
@ -723,10 +881,11 @@ pub fn fold_keyword<U, F: Fold<U> + ?Sized>(
node: Keyword<U>,
) -> Result<Keyword<F::TargetU>, F::Error> {
fold_attributed(folder, node, |folder, node| {
let KeywordData { arg, value } = node;
let KeywordData { range, arg, value } = node;
Ok(KeywordData {
arg: Foldable::fold(arg, folder)?,
value: Foldable::fold(value, folder)?,
range,
})
})
}
@ -744,10 +903,15 @@ pub fn fold_alias<U, F: Fold<U> + ?Sized>(
node: Alias<U>,
) -> Result<Alias<F::TargetU>, F::Error> {
fold_attributed(folder, node, |folder, node| {
let AliasData { name, asname } = node;
let AliasData {
range,
name,
asname,
} = node;
Ok(AliasData {
name: Foldable::fold(name, folder)?,
asname: Foldable::fold(asname, folder)?,
range,
})
})
}
@ -765,12 +929,14 @@ pub fn fold_withitem<U, F: Fold<U> + ?Sized>(
node: Withitem<U>,
) -> Result<Withitem<F::TargetU>, F::Error> {
let Withitem {
range,
context_expr,
optional_vars,
} = node;
Ok(Withitem {
context_expr: Foldable::fold(context_expr, folder)?,
optional_vars: Foldable::fold(optional_vars, folder)?,
range,
})
}
impl<T, U> Foldable<T, U> for MatchCase<T> {
@ -787,6 +953,7 @@ pub fn fold_match_case<U, F: Fold<U> + ?Sized>(
node: MatchCase<U>,
) -> Result<MatchCase<F::TargetU>, F::Error> {
let MatchCase {
range,
pattern,
guard,
body,
@ -795,6 +962,7 @@ pub fn fold_match_case<U, F: Fold<U> + ?Sized>(
pattern: Foldable::fold(pattern, folder)?,
guard: Foldable::fold(guard, folder)?,
body: Foldable::fold(body, folder)?,
range,
})
}
impl<T, U> Foldable<T, U> for Pattern<T> {
@ -811,22 +979,26 @@ pub fn fold_pattern<U, F: Fold<U> + ?Sized>(
node: Pattern<U>,
) -> Result<Pattern<F::TargetU>, F::Error> {
fold_attributed(folder, node, |folder, node| match node {
PatternKind::MatchValue(PatternMatchValue { value }) => {
PatternKind::MatchValue(PatternMatchValue { range, value }) => {
Ok(PatternKind::MatchValue(PatternMatchValue {
value: Foldable::fold(value, folder)?,
range,
}))
}
PatternKind::MatchSingleton(PatternMatchSingleton { value }) => {
PatternKind::MatchSingleton(PatternMatchSingleton { range, value }) => {
Ok(PatternKind::MatchSingleton(PatternMatchSingleton {
value: Foldable::fold(value, folder)?,
range,
}))
}
PatternKind::MatchSequence(PatternMatchSequence { patterns }) => {
PatternKind::MatchSequence(PatternMatchSequence { range, patterns }) => {
Ok(PatternKind::MatchSequence(PatternMatchSequence {
patterns: Foldable::fold(patterns, folder)?,
range,
}))
}
PatternKind::MatchMapping(PatternMatchMapping {
range,
keys,
patterns,
rest,
@ -834,8 +1006,10 @@ pub fn fold_pattern<U, F: Fold<U> + ?Sized>(
keys: Foldable::fold(keys, folder)?,
patterns: Foldable::fold(patterns, folder)?,
rest: Foldable::fold(rest, folder)?,
range,
})),
PatternKind::MatchClass(PatternMatchClass {
range,
cls,
patterns,
kwd_attrs,
@ -845,21 +1019,27 @@ pub fn fold_pattern<U, F: Fold<U> + ?Sized>(
patterns: Foldable::fold(patterns, folder)?,
kwd_attrs: Foldable::fold(kwd_attrs, folder)?,
kwd_patterns: Foldable::fold(kwd_patterns, folder)?,
range,
})),
PatternKind::MatchStar(PatternMatchStar { name }) => {
PatternKind::MatchStar(PatternMatchStar { range, name }) => {
Ok(PatternKind::MatchStar(PatternMatchStar {
name: Foldable::fold(name, folder)?,
range,
}))
}
PatternKind::MatchAs(PatternMatchAs { pattern, name }) => {
Ok(PatternKind::MatchAs(PatternMatchAs {
pattern: Foldable::fold(pattern, folder)?,
name: Foldable::fold(name, folder)?,
}))
}
PatternKind::MatchOr(PatternMatchOr { patterns }) => {
PatternKind::MatchAs(PatternMatchAs {
range,
pattern,
name,
}) => Ok(PatternKind::MatchAs(PatternMatchAs {
pattern: Foldable::fold(pattern, folder)?,
name: Foldable::fold(name, folder)?,
range,
})),
PatternKind::MatchOr(PatternMatchOr { range, patterns }) => {
Ok(PatternKind::MatchOr(PatternMatchOr {
patterns: Foldable::fold(patterns, folder)?,
range,
}))
}
})
@ -878,10 +1058,11 @@ pub fn fold_type_ignore<U, F: Fold<U> + ?Sized>(
node: TypeIgnore,
) -> Result<TypeIgnore, F::Error> {
match node {
TypeIgnore::TypeIgnore(TypeIgnoreTypeIgnore { lineno, tag }) => {
TypeIgnore::TypeIgnore(TypeIgnoreTypeIgnore { range, lineno, tag }) => {
Ok(TypeIgnore::TypeIgnore(TypeIgnoreTypeIgnore {
lineno: Foldable::fold(lineno, folder)?,
tag: Foldable::fold(tag, folder)?,
range,
}))
}
}

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

File diff suppressed because it is too large Load diff

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

@ -31,9 +31,9 @@ pub trait Visitor<U = ()> {
StmtKind::Global(data) => self.visit_stmt_Global(data),
StmtKind::Nonlocal(data) => self.visit_stmt_Nonlocal(data),
StmtKind::Expr(data) => self.visit_stmt_Expr(data),
StmtKind::Pass => self.visit_stmt_Pass(()),
StmtKind::Break => self.visit_stmt_Break(()),
StmtKind::Continue => self.visit_stmt_Continue(()),
StmtKind::Pass(data) => self.visit_stmt_Pass(data),
StmtKind::Break(data) => self.visit_stmt_Break(data),
StmtKind::Continue(data) => self.visit_stmt_Continue(data),
}
}
fn visit_stmt_FunctionDef(&mut self, node: StmtFunctionDef) {
@ -338,18 +338,9 @@ pub trait Visitor<U = ()> {
self.visit_expr(*value);
}
}
fn visit_stmt_Pass(&mut self, node: ()) {
self.generic_visit_stmt_Pass(())
}
fn generic_visit_stmt_Pass(&mut self, node: ()) {}
fn visit_stmt_Break(&mut self, node: ()) {
self.generic_visit_stmt_Break(())
}
fn generic_visit_stmt_Break(&mut self, node: ()) {}
fn visit_stmt_Continue(&mut self, node: ()) {
self.generic_visit_stmt_Continue(())
}
fn generic_visit_stmt_Continue(&mut self, node: ()) {}
fn visit_stmt_Pass(&mut self, node: StmtPass) {}
fn visit_stmt_Break(&mut self, node: StmtBreak) {}
fn visit_stmt_Continue(&mut self, node: StmtContinue) {}
fn visit_expr(&mut self, node: Expr) {
self.generic_visit_expr(node)
}

96
ast/src/impls.rs
View file

@ -1,4 +1,5 @@
use crate::{Constant, ExprKind};
use crate::text_size::TextRange;
use crate::{Constant, ExcepthandlerKind, ExprKind, PatternKind, Ranged, StmtKind};
impl<U> ExprKind<U> {
/// Returns a short name for the node suitable for use in error messages.
@ -40,7 +41,7 @@ impl<U> ExprKind<U> {
ExprKind::GeneratorExp { .. } => "generator expression",
ExprKind::Starred { .. } => "starred",
ExprKind::Slice { .. } => "slice",
ExprKind::JoinedStr(crate::ExprJoinedStr { values }) => {
ExprKind::JoinedStr(crate::ExprJoinedStr { values, .. }) => {
if values
.iter()
.any(|e| matches!(e.node, ExprKind::JoinedStr { .. }))
@ -58,3 +59,94 @@ impl<U> ExprKind<U> {
}
}
}
impl<U> Ranged for ExprKind<U> {
fn range(&self) -> TextRange {
match self {
ExprKind::BoolOp(node) => node.range(),
ExprKind::NamedExpr(node) => node.range(),
ExprKind::BinOp(node) => node.range(),
ExprKind::UnaryOp(node) => node.range(),
ExprKind::Lambda(node) => node.range(),
ExprKind::IfExp(node) => node.range(),
ExprKind::Dict(node) => node.range(),
ExprKind::Set(node) => node.range(),
ExprKind::ListComp(node) => node.range(),
ExprKind::SetComp(node) => node.range(),
ExprKind::DictComp(node) => node.range(),
ExprKind::GeneratorExp(node) => node.range(),
ExprKind::Await(node) => node.range(),
ExprKind::Yield(node) => node.range(),
ExprKind::YieldFrom(node) => node.range(),
ExprKind::Compare(node) => node.range(),
ExprKind::Call(node) => node.range(),
ExprKind::FormattedValue(node) => node.range(),
ExprKind::JoinedStr(node) => node.range(),
ExprKind::Constant(node) => node.range(),
ExprKind::Attribute(node) => node.range(),
ExprKind::Subscript(node) => node.range(),
ExprKind::Starred(node) => node.range(),
ExprKind::Name(node) => node.range(),
ExprKind::List(node) => node.range(),
ExprKind::Tuple(node) => node.range(),
ExprKind::Slice(node) => node.range(),
}
}
}
impl<U> Ranged for StmtKind<U> {
fn range(&self) -> TextRange {
match self {
StmtKind::FunctionDef(stmt) => stmt.range(),
StmtKind::AsyncFunctionDef(stmt) => stmt.range(),
StmtKind::ClassDef(stmt) => stmt.range(),
StmtKind::Return(stmt) => stmt.range(),
StmtKind::Delete(stmt) => stmt.range(),
StmtKind::Assign(stmt) => stmt.range(),
StmtKind::AugAssign(stmt) => stmt.range(),
StmtKind::AnnAssign(stmt) => stmt.range(),
StmtKind::For(stmt) => stmt.range(),
StmtKind::AsyncFor(stmt) => stmt.range(),
StmtKind::While(stmt) => stmt.range(),
StmtKind::If(stmt) => stmt.range(),
StmtKind::With(stmt) => stmt.range(),
StmtKind::AsyncWith(stmt) => stmt.range(),
StmtKind::Match(stmt) => stmt.range(),
StmtKind::Raise(stmt) => stmt.range(),
StmtKind::Try(stmt) => stmt.range(),
StmtKind::TryStar(stmt) => stmt.range(),
StmtKind::Assert(stmt) => stmt.range(),
StmtKind::Import(stmt) => stmt.range(),
StmtKind::ImportFrom(stmt) => stmt.range(),
StmtKind::Global(stmt) => stmt.range(),
StmtKind::Nonlocal(stmt) => stmt.range(),
StmtKind::Expr(stmt) => stmt.range(),
StmtKind::Pass(stmt) => stmt.range(),
StmtKind::Break(stmt) => stmt.range(),
StmtKind::Continue(stmt) => stmt.range(),
}
}
}
impl<U> Ranged for PatternKind<U> {
fn range(&self) -> TextRange {
match self {
PatternKind::MatchValue(pattern) => pattern.range(),
PatternKind::MatchSingleton(pattern) => pattern.range(),
PatternKind::MatchSequence(pattern) => pattern.range(),
PatternKind::MatchMapping(pattern) => pattern.range(),
PatternKind::MatchClass(pattern) => pattern.range(),
PatternKind::MatchStar(pattern) => pattern.range(),
PatternKind::MatchAs(pattern) => pattern.range(),
PatternKind::MatchOr(pattern) => pattern.range(),
}
}
}
impl<U> Ranged for ExcepthandlerKind<U> {
fn range(&self) -> TextRange {
match self {
ExcepthandlerKind::ExceptHandler(handler) => handler.range(),
}
}
}

13
ast/src/lib.rs
View file

@ -19,6 +19,18 @@ pub use rustpython_parser_core::{text_size, ConversionFlag};
pub type Suite<U = ()> = Vec<Stmt<U>>;
pub trait Ranged {
fn range(&self) -> TextRange;
fn start(&self) -> TextSize {
self.range().start()
}
fn end(&self) -> TextSize {
self.range().end()
}
}
#[cfg(feature = "fold")]
pub mod fold {
use super::generic::*;
@ -45,5 +57,6 @@ pub use visitor::Visitor;
#[cfg(feature = "constant-optimization")]
mod optimizer;
use crate::text_size::{TextRange, TextSize};
#[cfg(feature = "constant-optimization")]
pub use optimizer::ConstantOptimizer;

25
ast/src/optimizer.rs
View file

@ -21,7 +21,7 @@ impl<U> crate::fold::Fold<U> for ConstantOptimizer {
}
fn fold_expr(&mut self, node: crate::Expr<U>) -> Result<crate::Expr<U>, Self::Error> {
match node.node {
crate::ExprKind::Tuple(crate::ExprTuple { elts, ctx }) => {
crate::ExprKind::Tuple(crate::ExprTuple { elts, ctx, range }) => {
let elts = elts
.into_iter()
.map(|x| self.fold_expr(x))
@ -40,14 +40,14 @@ impl<U> crate::fold::Fold<U> for ConstantOptimizer {
crate::ExprKind::Constant(crate::ExprConstant {
value: Constant::Tuple(tuple),
kind: None,
range,
})
} else {
crate::ExprKind::Tuple(crate::ExprTuple { elts, ctx })
crate::ExprKind::Tuple(crate::ExprTuple { elts, ctx, range })
};
Ok(crate::Expr {
node: expr,
custom: node.custom,
range: node.range,
})
}
_ => crate::fold::fold_expr(self, node),
@ -58,7 +58,6 @@ impl<U> crate::fold::Fold<U> for ConstantOptimizer {
#[cfg(test)]
mod tests {
use num_bigint::BigInt;
use rustpython_parser_core::text_size::TextRange;
#[cfg(feature = "constant-optimization")]
#[test]
@ -69,67 +68,67 @@ mod tests {
#[allow(clippy::let_unit_value)]
let custom = ();
let ast = Attributed {
range,
custom,
node: ExprTuple {
ctx: ExprContext::Load,
elts: vec![
Attributed {
range,
custom,
node: ExprConstant {
value: BigInt::from(1).into(),
kind: None,
range,
}
.into(),
},
Attributed {
range,
custom,
node: ExprConstant {
value: BigInt::from(2).into(),
kind: None,
range,
}
.into(),
},
Attributed {
range,
custom,
node: ExprTuple {
ctx: ExprContext::Load,
elts: vec![
Attributed {
range,
custom,
node: ExprConstant {
value: BigInt::from(3).into(),
kind: None,
range,
}
.into(),
},
Attributed {
range,
custom,
node: ExprConstant {
value: BigInt::from(4).into(),
kind: None,
range,
}
.into(),
},
Attributed {
range,
custom,
node: ExprConstant {
value: BigInt::from(5).into(),
kind: None,
range,
}
.into(),
},
],
range,
}
.into(),
},
],
range,
}
.into(),
};
@ -139,7 +138,6 @@ mod tests {
assert_eq!(
new_ast,
Attributed {
range,
custom,
node: ExprConstant {
value: Constant::Tuple(vec![
@ -151,7 +149,8 @@ mod tests {
BigInt::from(5).into(),
])
]),
kind: None
kind: None,
range,
}
.into(),
}

11
ast/src/source_locator.rs
View file

@ -1,4 +1,5 @@
use crate::builtin::Attributed;
use crate::Ranged;
use rustpython_parser_core::source_code::{SourceLocation, SourceLocator, SourceRange};
impl crate::fold::Fold<()> for SourceLocator<'_> {
@ -13,11 +14,13 @@ impl crate::fold::Fold<()> for SourceLocator<'_> {
fn map_attributed<T>(
&mut self,
node: Attributed<T, ()>,
) -> Result<Attributed<T, Self::TargetU>, Self::Error> {
let start = self.locate(node.range.start());
let end = self.locate(node.range.end());
) -> Result<Attributed<T, Self::TargetU>, Self::Error>
where
T: Ranged,
{
let start = self.locate(node.start());
let end = self.locate(node.end());
Ok(Attributed {
range: node.range,
custom: (start..end).into(),
node: node.node,
})

121
ast/src/unparse.rs
View file

@ -74,7 +74,11 @@ impl<'a> Unparser<'a> {
}};
}
match &ast.node {
ExprKind::BoolOp(crate::ExprBoolOp { op, values }) => {
ExprKind::BoolOp(crate::ExprBoolOp {
op,
values,
range: _range,
}) => {
let (op, prec) = op_prec!(bin, op, Boolop, And("and", AND), Or("or", OR));
group_if!(prec, {
let mut first = true;
@ -84,14 +88,23 @@ impl<'a> Unparser<'a> {
}
})
}
ExprKind::NamedExpr(crate::ExprNamedExpr { target, value }) => {
ExprKind::NamedExpr(crate::ExprNamedExpr {
target,
value,
range: _range,
}) => {
group_if!(precedence::TUPLE, {
self.unparse_expr(target, precedence::ATOM)?;
self.p(" := ")?;
self.unparse_expr(value, precedence::ATOM)?;
})
}
ExprKind::BinOp(crate::ExprBinOp { left, op, right }) => {
ExprKind::BinOp(crate::ExprBinOp {
left,
op,
right,
range: _range,
}) => {
let right_associative = matches!(op, Operator::Pow);
let (op, prec) = op_prec!(
bin,
@ -117,7 +130,11 @@ impl<'a> Unparser<'a> {
self.unparse_expr(right, prec + !right_associative as u8)?;
})
}
ExprKind::UnaryOp(crate::ExprUnaryOp { op, operand }) => {
ExprKind::UnaryOp(crate::ExprUnaryOp {
op,
operand,
range: _range,
}) => {
let (op, prec) = op_prec!(
un,
op,
@ -132,7 +149,11 @@ impl<'a> Unparser<'a> {
self.unparse_expr(operand, prec)?;
})
}
ExprKind::Lambda(crate::ExprLambda { args, body }) => {
ExprKind::Lambda(crate::ExprLambda {
args,
body,
range: _range,
}) => {
group_if!(precedence::TEST, {
let pos = args.args.len() + args.posonlyargs.len();
self.p(if pos > 0 { "lambda " } else { "lambda" })?;
@ -140,7 +161,12 @@ impl<'a> Unparser<'a> {
write!(self, ": {}", **body)?;
})
}
ExprKind::IfExp(crate::ExprIfExp { test, body, orelse }) => {
ExprKind::IfExp(crate::ExprIfExp {
test,
body,
orelse,
range: _range,
}) => {
group_if!(precedence::TEST, {
self.unparse_expr(body, precedence::TEST + 1)?;
self.p(" if ")?;
@ -149,7 +175,11 @@ impl<'a> Unparser<'a> {
self.unparse_expr(orelse, precedence::TEST)?;
})
}
ExprKind::Dict(crate::ExprDict { keys, values }) => {
ExprKind::Dict(crate::ExprDict {
keys,
values,
range: _range,
}) => {
self.p("{")?;
let mut first = true;
let (packed, unpacked) = values.split_at(keys.len());
@ -167,7 +197,10 @@ impl<'a> Unparser<'a> {
}
self.p("}")?;
}
ExprKind::Set(crate::ExprSet { elts }) => {
ExprKind::Set(crate::ExprSet {
elts,
range: _range,
}) => {
self.p("{")?;
let mut first = true;
for v in elts {
@ -176,13 +209,21 @@ impl<'a> Unparser<'a> {
}
self.p("}")?;
}
ExprKind::ListComp(crate::ExprListComp { elt, generators }) => {
ExprKind::ListComp(crate::ExprListComp {
elt,
generators,
range: _range,
}) => {
self.p("[")?;
self.unparse_expr(elt, precedence::TEST)?;
self.unparse_comp(generators)?;
self.p("]")?;
}
ExprKind::SetComp(crate::ExprSetComp { elt, generators }) => {
ExprKind::SetComp(crate::ExprSetComp {
elt,
generators,
range: _range,
}) => {
self.p("{")?;
self.unparse_expr(elt, precedence::TEST)?;
self.unparse_comp(generators)?;
@ -192,6 +233,7 @@ impl<'a> Unparser<'a> {
key,
value,
generators,
range: _range,
}) => {
self.p("{")?;
self.unparse_expr(key, precedence::TEST)?;
@ -200,32 +242,46 @@ impl<'a> Unparser<'a> {
self.unparse_comp(generators)?;
self.p("}")?;
}
ExprKind::GeneratorExp(crate::ExprGeneratorExp { elt, generators }) => {
ExprKind::GeneratorExp(crate::ExprGeneratorExp {
elt,
generators,
range: _range,
}) => {
self.p("(")?;
self.unparse_expr(elt, precedence::TEST)?;
self.unparse_comp(generators)?;
self.p(")")?;
}
ExprKind::Await(crate::ExprAwait { value }) => {
ExprKind::Await(crate::ExprAwait {
value,
range: _range,
}) => {
group_if!(precedence::AWAIT, {
self.p("await ")?;
self.unparse_expr(value, precedence::ATOM)?;
})
}
ExprKind::Yield(crate::ExprYield { value }) => {
ExprKind::Yield(crate::ExprYield {
value,
range: _range,
}) => {
if let Some(value) = value {
write!(self, "(yield {})", **value)?;
} else {
self.p("(yield)")?;
}
}
ExprKind::YieldFrom(crate::ExprYieldFrom { value }) => {
ExprKind::YieldFrom(crate::ExprYieldFrom {
value,
range: _range,
}) => {
write!(self, "(yield from {})", **value)?;
}
ExprKind::Compare(crate::ExprCompare {
left,
ops,
comparators,
range: _range,
}) => {
group_if!(precedence::CMP, {
let new_lvl = precedence::CMP + 1;
@ -252,12 +308,18 @@ impl<'a> Unparser<'a> {
func,
args,
keywords,
range: _range,
}) => {
self.unparse_expr(func, precedence::ATOM)?;
self.p("(")?;
if let (
[Expr {
node: ExprKind::GeneratorExp(crate::ExprGeneratorExp { elt, generators }),
node:
ExprKind::GeneratorExp(crate::ExprGeneratorExp {
elt,
generators,
range: _range,
}),
..
}],
[],
@ -289,11 +351,17 @@ impl<'a> Unparser<'a> {
value,
conversion,
format_spec,
range: _range,
}) => self.unparse_formatted(value, conversion.to_u32(), format_spec.as_deref())?,
ExprKind::JoinedStr(crate::ExprJoinedStr { values }) => {
self.unparse_joined_str(values, false)?
}
ExprKind::Constant(crate::ExprConstant { value, kind }) => {
ExprKind::JoinedStr(crate::ExprJoinedStr {
values,
range: _range,
}) => self.unparse_joined_str(values, false)?,
ExprKind::Constant(crate::ExprConstant {
value,
kind,
range: _range,
}) => {
if let Some(kind) = kind {
self.p(kind)?;
}
@ -366,7 +434,12 @@ impl<'a> Unparser<'a> {
})
}
}
ExprKind::Slice(crate::ExprSlice { lower, upper, step }) => {
ExprKind::Slice(crate::ExprSlice {
lower,
upper,
step,
range: _range,
}) => {
if let Some(lower) = lower {
self.unparse_expr(lower, precedence::TEST)?;
}
@ -495,13 +568,15 @@ impl<'a> Unparser<'a> {
unreachable!()
}
}
ExprKind::JoinedStr(crate::ExprJoinedStr { values }) => {
self.unparse_joined_str(values, is_spec)
}
ExprKind::JoinedStr(crate::ExprJoinedStr {
values,
range: _range,
}) => self.unparse_joined_str(values, is_spec),
ExprKind::FormattedValue(crate::ExprFormattedValue {
value,
conversion,
format_spec,
range: _range,
}) => self.unparse_formatted(value, conversion.to_u32(), format_spec.as_deref()),
_ => unreachable!(),
}

40
parser/src/context.rs
View file

@ -2,43 +2,65 @@ use crate::ast::{self, Expr, ExprContext, ExprKind};
pub(crate) fn set_context(expr: Expr, ctx: ExprContext) -> Expr {
match expr.node {
ExprKind::Name(ast::ExprName { id, .. }) => Expr {
node: ast::ExprName { id, ctx }.into(),
ExprKind::Name(ast::ExprName { id, range, .. }) => Expr {
node: ast::ExprName { id, ctx, range }.into(),
..expr
},
ExprKind::Tuple(ast::ExprTuple { elts, .. }) => Expr {
ExprKind::Tuple(ast::ExprTuple { elts, range, .. }) => Expr {
node: ast::ExprTuple {
elts: elts
.into_iter()
.map(|elt| set_context(elt, ctx.clone()))
.collect(),
range,
ctx,
}
.into(),
..expr
},
ExprKind::List(ast::ExprList { elts, .. }) => Expr {
ExprKind::List(ast::ExprList { elts, range, .. }) => Expr {
node: ast::ExprList {
elts: elts
.into_iter()
.map(|elt| set_context(elt, ctx.clone()))
.collect(),
range,
ctx,
}
.into(),
..expr
},
ExprKind::Attribute(ast::ExprAttribute { value, attr, .. }) => Expr {
node: ast::ExprAttribute { value, attr, ctx }.into(),
ExprKind::Attribute(ast::ExprAttribute {
value, attr, range, ..
}) => Expr {
node: ast::ExprAttribute {
value,
attr,
range,
ctx,
}
.into(),
..expr
},
ExprKind::Subscript(ast::ExprSubscript { value, slice, .. }) => Expr {
node: ast::ExprSubscript { value, slice, ctx }.into(),
ExprKind::Subscript(ast::ExprSubscript {
value,
slice,
range,
..
}) => Expr {
node: ast::ExprSubscript {
value,
slice,
range,
ctx,
}
.into(),
..expr
},
ExprKind::Starred(ast::ExprStarred { value, .. }) => Expr {
ExprKind::Starred(ast::ExprStarred { value, range, .. }) => Expr {
node: ast::ExprStarred {
value: Box::new(set_context(*value, ctx.clone())),
range,
ctx,
}
.into(),

14
parser/src/function.rs
View file

@ -1,11 +1,13 @@
// Contains functions that perform validation and parsing of arguments and parameters.
// Checks apply both to functions and to lambdas.
use crate::text_size::TextRange;
use crate::{
ast,
lexer::{LexicalError, LexicalErrorType},
text_size::TextSize,
};
use rustc_hash::FxHashSet;
use rustpython_ast::Ranged;
pub(crate) struct ArgumentList {
pub args: Vec<ast::Expr>,
@ -116,13 +118,11 @@ pub(crate) fn parse_args(func_args: Vec<FunctionArgument>) -> Result<ArgumentLis
double_starred = true;
}
keywords.push(ast::Keyword::new(
start..end,
ast::KeywordData {
arg: name.map(ast::Identifier::new),
value,
},
));
keywords.push(ast::Keyword::new(ast::KeywordData {
arg: name.map(ast::Identifier::new),
value,
range: TextRange::new(start, end),
}));
}
None => {
// Positional arguments mustn't follow keyword arguments.

2
parser/src/parser.rs
View file

@ -95,7 +95,7 @@ pub fn parse_expression_starts_at(
offset: TextSize,
) -> Result<ast::Expr, ParseError> {
parse_starts_at(source, Mode::Expression, path, offset).map(|top| match top {
ast::Mod::Expression(ast::ModExpression { body }) => *body,
ast::Mod::Expression(ast::ModExpression { body, .. }) => *body,
_ => unreachable!(),
})
}

497
parser/src/python.lalrpop
View file

File diff suppressed because it is too large Load diff

23385
parser/src/python.rs generated
View file

File diff suppressed because it is too large Load diff

8
parser/src/snapshots/rustpython_parser__context__tests__ann_assign_name.snap generated
View file

@ -4,12 +4,10 @@ expression: parse_ast
---
[
Attributed {
range: 0..10,
custom: (),
node: AnnAssign(
StmtAnnAssign {
target: Attributed {
range: 0..1,
custom: (),
node: Name(
ExprName {
@ -17,11 +15,11 @@ expression: parse_ast
"x",
),
ctx: Store,
range: 0..1,
},
),
},
annotation: Attributed {
range: 3..6,
custom: (),
node: Name(
ExprName {
@ -29,12 +27,12 @@ expression: parse_ast
"int",
),
ctx: Load,
range: 3..6,
},
),
},
value: Some(
Attributed {
range: 9..10,
custom: (),
node: Constant(
ExprConstant {
@ -42,11 +40,13 @@ expression: parse_ast
1,
),
kind: None,
range: 9..10,
},
),
},
),
simple: true,
range: 0..10,
},
),
},

14
parser/src/snapshots/rustpython_parser__context__tests__assign_attribute.snap generated
View file

@ -4,18 +4,15 @@ expression: parse_ast
---
[
Attributed {
range: 0..15,
custom: (),
node: Assign(
StmtAssign {
targets: [
Attributed {
range: 0..3,
custom: (),
node: Attribute(
ExprAttribute {
value: Attributed {
range: 0..1,
custom: (),
node: Name(
ExprName {
@ -23,6 +20,7 @@ expression: parse_ast
"x",
),
ctx: Load,
range: 0..1,
},
),
},
@ -30,18 +28,17 @@ expression: parse_ast
"y",
),
ctx: Store,
range: 0..3,
},
),
},
],
value: Attributed {
range: 6..15,
custom: (),
node: Tuple(
ExprTuple {
elts: [
Attributed {
range: 7..8,
custom: (),
node: Constant(
ExprConstant {
@ -49,11 +46,11 @@ expression: parse_ast
1,
),
kind: None,
range: 7..8,
},
),
},
Attributed {
range: 10..11,
custom: (),
node: Constant(
ExprConstant {
@ -61,11 +58,11 @@ expression: parse_ast
2,
),
kind: None,
range: 10..11,
},
),
},
Attributed {
range: 13..14,
custom: (),
node: Constant(
ExprConstant {
@ -73,15 +70,18 @@ expression: parse_ast
3,
),
kind: None,
range: 13..14,
},
),
},
],
ctx: Load,
range: 6..15,
},
),
},
type_comment: None,
range: 0..15,
},
),
},

19
parser/src/snapshots/rustpython_parser__context__tests__assign_for.snap generated
View file

@ -4,12 +4,10 @@ expression: parse_ast
---
[
Attributed {
range: 0..24,
custom: (),
node: For(
StmtFor {
target: Attributed {
range: 4..5,
custom: (),
node: Name(
ExprName {
@ -17,17 +15,16 @@ expression: parse_ast
"x",
),
ctx: Store,
range: 4..5,
},
),
},
iter: Attributed {
range: 9..18,
custom: (),
node: Tuple(
ExprTuple {
elts: [
Attributed {
range: 10..11,
custom: (),
node: Constant(
ExprConstant {
@ -35,11 +32,11 @@ expression: parse_ast
1,
),
kind: None,
range: 10..11,
},
),
},
Attributed {
range: 13..14,
custom: (),
node: Constant(
ExprConstant {
@ -47,11 +44,11 @@ expression: parse_ast
2,
),
kind: None,
range: 13..14,
},
),
},
Attributed {
range: 16..17,
custom: (),
node: Constant(
ExprConstant {
@ -59,23 +56,29 @@ expression: parse_ast
3,
),
kind: None,
range: 16..17,
},
),
},
],
ctx: Load,
range: 9..18,
},
),
},
body: [
Attributed {
range: 20..24,
custom: (),
node: Pass,
node: Pass(
StmtPass {
range: 20..24,
},
),
},
],
orelse: [],
type_comment: None,
range: 0..24,
},
),
},

16
parser/src/snapshots/rustpython_parser__context__tests__assign_list.snap generated
View file

@ -4,19 +4,16 @@ expression: parse_ast
---
[
Attributed {
range: 0..18,
custom: (),
node: Assign(
StmtAssign {
targets: [
Attributed {
range: 0..6,
custom: (),
node: List(
ExprList {
elts: [
Attributed {
range: 1..2,
custom: (),
node: Name(
ExprName {
@ -24,11 +21,11 @@ expression: parse_ast
"x",
),
ctx: Store,
range: 1..2,
},
),
},
Attributed {
range: 4..5,
custom: (),
node: Name(
ExprName {
@ -36,23 +33,23 @@ expression: parse_ast
"y",
),
ctx: Store,
range: 4..5,
},
),
},
],
ctx: Store,
range: 0..6,
},
),
},
],
value: Attributed {
range: 9..18,
custom: (),
node: Tuple(
ExprTuple {
elts: [
Attributed {
range: 10..11,
custom: (),
node: Constant(
ExprConstant {
@ -60,11 +57,11 @@ expression: parse_ast
1,
),
kind: None,
range: 10..11,
},
),
},
Attributed {
range: 13..14,
custom: (),
node: Constant(
ExprConstant {
@ -72,11 +69,11 @@ expression: parse_ast
2,
),
kind: None,
range: 13..14,
},
),
},
Attributed {
range: 16..17,
custom: (),
node: Constant(
ExprConstant {
@ -84,15 +81,18 @@ expression: parse_ast
3,
),
kind: None,
range: 16..17,
},
),
},
],
ctx: Load,
range: 9..18,
},
),
},
type_comment: None,
range: 0..18,
},
),
},

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

@ -4,13 +4,11 @@ expression: parse_ast
---
[
Attributed {
range: 0..26,
custom: (),
node: Assign(
StmtAssign {
targets: [
Attributed {
range: 0..1,
custom: (),
node: Name(
ExprName {
@ -18,17 +16,16 @@ expression: parse_ast
"x",
),
ctx: Store,
range: 0..1,
},
),
},
],
value: Attributed {
range: 4..26,
custom: (),
node: ListComp(
ExprListComp {
elt: Attributed {
range: 5..6,
custom: (),
node: Name(
ExprName {
@ -36,13 +33,13 @@ expression: parse_ast
"y",
),
ctx: Load,
range: 5..6,
},
),
},
generators: [
Comprehension {
target: Attributed {
range: 11..12,
custom: (),
node: Name(
ExprName {
@ -50,17 +47,16 @@ expression: parse_ast
"y",
),
ctx: Store,
range: 11..12,
},
),
},
iter: Attributed {
range: 16..25,
custom: (),
node: Tuple(
ExprTuple {
elts: [
Attributed {
range: 17..18,
custom: (),
node: Constant(
ExprConstant {
@ -68,11 +64,11 @@ expression: parse_ast
1,
),
kind: None,
range: 17..18,
},
),
},
Attributed {
range: 20..21,
custom: (),
node: Constant(
ExprConstant {
@ -80,11 +76,11 @@ expression: parse_ast
2,
),
kind: None,
range: 20..21,
},
),
},
Attributed {
range: 23..24,
custom: (),
node: Constant(
ExprConstant {
@ -92,22 +88,27 @@ expression: parse_ast
3,
),
kind: None,
range: 23..24,
},
),
},
],
ctx: Load,
range: 16..25,
},
),
},
ifs: [],
is_async: false,
range: 7..25,
},
],
range: 4..26,
},
),
},
type_comment: None,
range: 0..26,
},
),
},

12
parser/src/snapshots/rustpython_parser__context__tests__assign_name.snap generated
View file

@ -4,13 +4,11 @@ expression: parse_ast
---
[
Attributed {
range: 0..13,
custom: (),
node: Assign(
StmtAssign {
targets: [
Attributed {
range: 0..1,
custom: (),
node: Name(
ExprName {
@ -18,18 +16,17 @@ expression: parse_ast
"x",
),
ctx: Store,
range: 0..1,
},
),
},
],
value: Attributed {
range: 4..13,
custom: (),
node: Tuple(
ExprTuple {
elts: [
Attributed {
range: 5..6,
custom: (),
node: Constant(
ExprConstant {
@ -37,11 +34,11 @@ expression: parse_ast
1,
),
kind: None,
range: 5..6,
},
),
},
Attributed {
range: 8..9,
custom: (),
node: Constant(
ExprConstant {
@ -49,11 +46,11 @@ expression: parse_ast
2,
),
kind: None,
range: 8..9,
},
),
},
Attributed {
range: 11..12,
custom: (),
node: Constant(
ExprConstant {
@ -61,15 +58,18 @@ expression: parse_ast
3,
),
kind: None,
range: 11..12,
},
),
},
],
ctx: Load,
range: 4..13,
},
),
},
type_comment: None,
range: 0..13,
},
),
},

15
parser/src/snapshots/rustpython_parser__context__tests__assign_named_expr.snap generated
View file

@ -4,17 +4,14 @@ expression: parse_ast
---
[
Attributed {
range: 0..14,
custom: (),
node: If(
StmtIf {
test: Attributed {
range: 3..8,
custom: (),
node: NamedExpr(
ExprNamedExpr {
target: Attributed {
range: 3..4,
custom: (),
node: Name(
ExprName {
@ -22,11 +19,11 @@ expression: parse_ast
"x",
),
ctx: Store,
range: 3..4,
},
),
},
value: Attributed {
range: 7..8,
custom: (),
node: Constant(
ExprConstant {
@ -34,20 +31,26 @@ expression: parse_ast
1,
),
kind: None,
range: 7..8,
},
),
},
range: 3..8,
},
),
},
body: [
Attributed {
range: 10..14,
custom: (),
node: Pass,
node: Pass(
StmtPass {
range: 10..14,
},
),
},
],
orelse: [],
range: 0..14,
},
),
},

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

@ -4,13 +4,11 @@ expression: parse_ast
---
[
Attributed {
range: 0..26,
custom: (),
node: Assign(
StmtAssign {
targets: [
Attributed {
range: 0..1,
custom: (),
node: Name(
ExprName {
@ -18,17 +16,16 @@ expression: parse_ast
"x",
),
ctx: Store,
range: 0..1,
},
),
},
],
value: Attributed {
range: 4..26,
custom: (),
node: SetComp(
ExprSetComp {
elt: Attributed {
range: 5..6,
custom: (),
node: Name(
ExprName {
@ -36,13 +33,13 @@ expression: parse_ast
"y",
),
ctx: Load,
range: 5..6,
},
),
},
generators: [
Comprehension {
target: Attributed {
range: 11..12,
custom: (),
node: Name(
ExprName {
@ -50,17 +47,16 @@ expression: parse_ast
"y",
),
ctx: Store,
range: 11..12,
},
),
},
iter: Attributed {
range: 16..25,
custom: (),
node: Tuple(
ExprTuple {
elts: [
Attributed {
range: 17..18,
custom: (),
node: Constant(
ExprConstant {
@ -68,11 +64,11 @@ expression: parse_ast
1,
),
kind: None,
range: 17..18,
},
),
},
Attributed {
range: 20..21,
custom: (),
node: Constant(
ExprConstant {
@ -80,11 +76,11 @@ expression: parse_ast
2,
),
kind: None,
range: 20..21,
},
),
},
Attributed {
range: 23..24,
custom: (),
node: Constant(
ExprConstant {
@ -92,22 +88,27 @@ expression: parse_ast
3,
),
kind: None,
range: 23..24,
},
),
},
],
ctx: Load,
range: 16..25,
},
),
},
ifs: [],
is_async: false,
range: 7..25,
},
],
range: 4..26,
},
),
},
type_comment: None,
range: 0..26,
},
),
},

18
parser/src/snapshots/rustpython_parser__context__tests__assign_starred.snap generated
View file

@ -4,19 +4,16 @@ expression: parse_ast
---
[
Attributed {
range: 0..19,
custom: (),
node: Assign(
StmtAssign {
targets: [
Attributed {
range: 0..7,
custom: (),
node: Tuple(
ExprTuple {
elts: [
Attributed {
range: 1..2,
custom: (),
node: Name(
ExprName {
@ -24,16 +21,15 @@ expression: parse_ast
"x",
),
ctx: Store,
range: 1..2,
},
),
},
Attributed {
range: 4..6,
custom: (),
node: Starred(
ExprStarred {
value: Attributed {
range: 5..6,
custom: (),
node: Name(
ExprName {
@ -41,27 +37,28 @@ expression: parse_ast
"y",
),
ctx: Store,
range: 5..6,
},
),
},
ctx: Store,
range: 4..6,
},
),
},
],
ctx: Store,
range: 0..7,
},
),
},
],
value: Attributed {
range: 10..19,
custom: (),
node: Tuple(
ExprTuple {
elts: [
Attributed {
range: 11..12,
custom: (),
node: Constant(
ExprConstant {
@ -69,11 +66,11 @@ expression: parse_ast
1,
),
kind: None,
range: 11..12,
},
),
},
Attributed {
range: 14..15,
custom: (),
node: Constant(
ExprConstant {
@ -81,11 +78,11 @@ expression: parse_ast
2,
),
kind: None,
range: 14..15,
},
),
},
Attributed {
range: 17..18,
custom: (),
node: Constant(
ExprConstant {
@ -93,15 +90,18 @@ expression: parse_ast
3,
),
kind: None,
range: 17..18,
},
),
},
],
ctx: Load,
range: 10..19,
},
),
},
type_comment: None,
range: 0..19,
},
),
},

16
parser/src/snapshots/rustpython_parser__context__tests__assign_subscript.snap generated
View file

@ -4,18 +4,15 @@ expression: parse_ast
---
[
Attributed {
range: 0..16,
custom: (),
node: Assign(
StmtAssign {
targets: [
Attributed {
range: 0..4,
custom: (),
node: Subscript(
ExprSubscript {
value: Attributed {
range: 0..1,
custom: (),
node: Name(
ExprName {
@ -23,11 +20,11 @@ expression: parse_ast
"x",
),
ctx: Load,
range: 0..1,
},
),
},
slice: Attributed {
range: 2..3,
custom: (),
node: Name(
ExprName {
@ -35,22 +32,22 @@ expression: parse_ast
"y",
),
ctx: Load,
range: 2..3,
},
),
},
ctx: Store,
range: 0..4,
},
),
},
],
value: Attributed {
range: 7..16,
custom: (),
node: Tuple(
ExprTuple {
elts: [
Attributed {
range: 8..9,
custom: (),
node: Constant(
ExprConstant {
@ -58,11 +55,11 @@ expression: parse_ast
1,
),
kind: None,
range: 8..9,
},
),
},
Attributed {
range: 11..12,
custom: (),
node: Constant(
ExprConstant {
@ -70,11 +67,11 @@ expression: parse_ast
2,
),
kind: None,
range: 11..12,
},
),
},
Attributed {
range: 14..15,
custom: (),
node: Constant(
ExprConstant {
@ -82,15 +79,18 @@ expression: parse_ast
3,
),
kind: None,
range: 14..15,
},
),
},
],
ctx: Load,
range: 7..16,
},
),
},
type_comment: None,
range: 0..16,
},
),
},

16
parser/src/snapshots/rustpython_parser__context__tests__assign_tuple.snap generated
View file

@ -4,19 +4,16 @@ expression: parse_ast
---
[
Attributed {
range: 0..18,
custom: (),
node: Assign(
StmtAssign {
targets: [
Attributed {
range: 0..6,
custom: (),
node: Tuple(
ExprTuple {
elts: [
Attributed {
range: 1..2,
custom: (),
node: Name(
ExprName {
@ -24,11 +21,11 @@ expression: parse_ast
"x",
),
ctx: Store,
range: 1..2,
},
),
},
Attributed {
range: 4..5,
custom: (),
node: Name(
ExprName {
@ -36,23 +33,23 @@ expression: parse_ast
"y",
),
ctx: Store,
range: 4..5,
},
),
},
],
ctx: Store,
range: 0..6,
},
),
},
],
value: Attributed {
range: 9..18,
custom: (),
node: Tuple(
ExprTuple {
elts: [
Attributed {
range: 10..11,
custom: (),
node: Constant(
ExprConstant {
@ -60,11 +57,11 @@ expression: parse_ast
1,
),
kind: None,
range: 10..11,
},
),
},
Attributed {
range: 13..14,
custom: (),
node: Constant(
ExprConstant {
@ -72,11 +69,11 @@ expression: parse_ast
2,
),
kind: None,
range: 13..14,
},
),
},
Attributed {
range: 16..17,
custom: (),
node: Constant(
ExprConstant {
@ -84,15 +81,18 @@ expression: parse_ast
3,
),
kind: None,
range: 16..17,
},
),
},
],
ctx: Load,
range: 9..18,
},
),
},
type_comment: None,
range: 0..18,
},
),
},

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

@ -4,14 +4,12 @@ expression: parse_ast
---
[
Attributed {
range: 0..17,
custom: (),
node: With(
StmtWith {
items: [
Withitem {
context_expr: Attributed {
range: 5..6,
custom: (),
node: Constant(
ExprConstant {
@ -19,12 +17,12 @@ expression: parse_ast
1,
),
kind: None,
range: 5..6,
},
),
},
optional_vars: Some(
Attributed {
range: 10..11,
custom: (),
node: Name(
ExprName {
@ -32,20 +30,26 @@ expression: parse_ast
"x",
),
ctx: Store,
range: 10..11,
},
),
},
),
range: 5..11,
},
],
body: [
Attributed {
range: 13..17,
custom: (),
node: Pass,
node: Pass(
StmtPass {
range: 13..17,
},
),
},
],
type_comment: None,
range: 0..17,
},
),
},

14
parser/src/snapshots/rustpython_parser__context__tests__aug_assign_attribute.snap generated
View file

@ -4,17 +4,14 @@ expression: parse_ast
---
[
Attributed {
range: 0..16,
custom: (),
node: AugAssign(
StmtAugAssign {
target: Attributed {
range: 0..3,
custom: (),
node: Attribute(
ExprAttribute {
value: Attributed {
range: 0..1,
custom: (),
node: Name(
ExprName {
@ -22,6 +19,7 @@ expression: parse_ast
"x",
),
ctx: Load,
range: 0..1,
},
),
},
@ -29,18 +27,17 @@ expression: parse_ast
"y",
),
ctx: Store,
range: 0..3,
},
),
},
op: Add,
value: Attributed {
range: 7..16,
custom: (),
node: Tuple(
ExprTuple {
elts: [
Attributed {
range: 8..9,
custom: (),
node: Constant(
ExprConstant {
@ -48,11 +45,11 @@ expression: parse_ast
1,
),
kind: None,
range: 8..9,
},
),
},
Attributed {
range: 11..12,
custom: (),
node: Constant(
ExprConstant {
@ -60,11 +57,11 @@ expression: parse_ast
2,
),
kind: None,
range: 11..12,
},
),
},
Attributed {
range: 14..15,
custom: (),
node: Constant(
ExprConstant {
@ -72,14 +69,17 @@ expression: parse_ast
3,
),
kind: None,
range: 14..15,
},
),
},
],
ctx: Load,
range: 7..16,
},
),
},
range: 0..16,
},
),
},

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

@ -4,12 +4,10 @@ expression: parse_ast
---
[
Attributed {
range: 0..6,
custom: (),
node: AugAssign(
StmtAugAssign {
target: Attributed {
range: 0..1,
custom: (),
node: Name(
ExprName {
@ -17,12 +15,12 @@ expression: parse_ast
"x",
),
ctx: Store,
range: 0..1,
},
),
},
op: Add,
value: Attributed {
range: 5..6,
custom: (),
node: Constant(
ExprConstant {
@ -30,9 +28,11 @@ expression: parse_ast
1,
),
kind: None,
range: 5..6,
},
),
},
range: 0..6,
},
),
},

16
parser/src/snapshots/rustpython_parser__context__tests__aug_assign_subscript.snap generated
View file

@ -4,17 +4,14 @@ expression: parse_ast
---
[
Attributed {
range: 0..17,
custom: (),
node: AugAssign(
StmtAugAssign {
target: Attributed {
range: 0..4,
custom: (),
node: Subscript(
ExprSubscript {
value: Attributed {
range: 0..1,
custom: (),
node: Name(
ExprName {
@ -22,11 +19,11 @@ expression: parse_ast
"x",
),
ctx: Load,
range: 0..1,
},
),
},
slice: Attributed {
range: 2..3,
custom: (),
node: Name(
ExprName {
@ -34,22 +31,22 @@ expression: parse_ast
"y",
),
ctx: Load,
range: 2..3,
},
),
},
ctx: Store,
range: 0..4,
},
),
},
op: Add,
value: Attributed {
range: 8..17,
custom: (),
node: Tuple(
ExprTuple {
elts: [
Attributed {
range: 9..10,
custom: (),
node: Constant(
ExprConstant {
@ -57,11 +54,11 @@ expression: parse_ast
1,
),
kind: None,
range: 9..10,
},
),
},
Attributed {
range: 12..13,
custom: (),
node: Constant(
ExprConstant {
@ -69,11 +66,11 @@ expression: parse_ast
2,
),
kind: None,
range: 12..13,
},
),
},
Attributed {
range: 15..16,
custom: (),
node: Constant(
ExprConstant {
@ -81,14 +78,17 @@ expression: parse_ast
3,
),
kind: None,
range: 15..16,
},
),
},
],
ctx: Load,
range: 8..17,
},
),
},
range: 0..17,
},
),
},

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

@ -4,18 +4,15 @@ expression: parse_ast
---
[
Attributed {
range: 0..7,
custom: (),
node: Delete(
StmtDelete {
targets: [
Attributed {
range: 4..7,
custom: (),
node: Attribute(
ExprAttribute {
value: Attributed {
range: 4..5,
custom: (),
node: Name(
ExprName {
@ -23,6 +20,7 @@ expression: parse_ast
"x",
),
ctx: Load,
range: 4..5,
},
),
},
@ -30,10 +28,12 @@ expression: parse_ast
"y",
),
ctx: Del,
range: 4..7,
},
),
},
],
range: 0..7,
},
),
},

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

@ -4,13 +4,11 @@ expression: parse_ast
---
[
Attributed {
range: 0..5,
custom: (),
node: Delete(
StmtDelete {
targets: [
Attributed {
range: 4..5,
custom: (),
node: Name(
ExprName {
@ -18,10 +16,12 @@ expression: parse_ast
"x",
),
ctx: Del,
range: 4..5,
},
),
},
],
range: 0..5,
},
),
},

8
parser/src/snapshots/rustpython_parser__context__tests__del_subscript.snap generated
View file

@ -4,18 +4,15 @@ expression: parse_ast
---
[
Attributed {
range: 0..8,
custom: (),
node: Delete(
StmtDelete {
targets: [
Attributed {
range: 4..8,
custom: (),
node: Subscript(
ExprSubscript {
value: Attributed {
range: 4..5,
custom: (),
node: Name(
ExprName {
@ -23,11 +20,11 @@ expression: parse_ast
"x",
),
ctx: Load,
range: 4..5,
},
),
},
slice: Attributed {
range: 6..7,
custom: (),
node: Name(
ExprName {
@ -35,14 +32,17 @@ expression: parse_ast
"y",
),
ctx: Load,
range: 6..7,
},
),
},
ctx: Del,
range: 4..8,
},
),
},
],
range: 0..8,
},
),
},

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

@ -5,7 +5,6 @@ expression: parse_ast
Ok(
[
Attributed {
range: 0..23,
custom: (),
node: FunctionDef(
StmtFunctionDef {
@ -18,7 +17,6 @@ Ok(
vararg: None,
kwonlyargs: [
Attributed {
range: 9..10,
custom: (),
node: ArgData {
arg: Identifier(
@ -26,10 +24,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 9..10,
},
},
Attributed {
range: 12..13,
custom: (),
node: ArgData {
arg: Identifier(
@ -37,10 +35,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 12..13,
},
},
Attributed {
range: 15..16,
custom: (),
node: ArgData {
arg: Identifier(
@ -48,23 +46,29 @@ Ok(
),
annotation: None,
type_comment: None,
range: 15..16,
},
},
],
kw_defaults: [],
kwarg: None,
defaults: [],
range: 6..16,
},
body: [
Attributed {
range: 19..23,
custom: (),
node: Pass,
node: Pass(
StmtPass {
range: 19..23,
},
),
},
],
decorator_list: [],
returns: None,
type_comment: None,
range: 0..23,
},
),
},

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

@ -5,7 +5,6 @@ expression: parse_ast
Ok(
[
Attributed {
range: 0..29,
custom: (),
node: FunctionDef(
StmtFunctionDef {
@ -18,7 +17,6 @@ Ok(
vararg: None,
kwonlyargs: [
Attributed {
range: 9..10,
custom: (),
node: ArgData {
arg: Identifier(
@ -26,10 +24,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 9..10,
},
},
Attributed {
range: 12..13,
custom: (),
node: ArgData {
arg: Identifier(
@ -37,10 +35,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 12..13,
},
},
Attributed {
range: 18..19,
custom: (),
node: ArgData {
arg: Identifier(
@ -48,12 +46,12 @@ Ok(
),
annotation: None,
type_comment: None,
range: 18..19,
},
},
],
kw_defaults: [
Attributed {
range: 14..16,
custom: (),
node: Constant(
ExprConstant {
@ -61,11 +59,11 @@ Ok(
20,
),
kind: None,
range: 14..16,
},
),
},
Attributed {
range: 20..22,
custom: (),
node: Constant(
ExprConstant {
@ -73,23 +71,29 @@ Ok(
30,
),
kind: None,
range: 20..22,
},
),
},
],
kwarg: None,
defaults: [],
range: 6..22,
},
body: [
Attributed {
range: 25..29,
custom: (),
node: Pass,
node: Pass(
StmtPass {
range: 25..29,
},
),
},
],
decorator_list: [],
returns: None,
type_comment: None,
range: 0..29,
},
),
},

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

@ -5,7 +5,6 @@ expression: parse_ast
Ok(
[
Attributed {
range: 0..13,
custom: (),
node: FunctionDef(
StmtFunctionDef {
@ -20,17 +19,22 @@ Ok(
kw_defaults: [],
kwarg: None,
defaults: [],
range: 5..7,
},
body: [
Attributed {
range: 9..13,
custom: (),
node: Pass,
node: Pass(
StmtPass {
range: 9..13,
},
),
},
],
decorator_list: [],
returns: None,
type_comment: None,
range: 0..13,
},
),
},

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

@ -5,7 +5,6 @@ expression: parse_ast
Ok(
[
Attributed {
range: 0..32,
custom: (),
node: FunctionDef(
StmtFunctionDef {
@ -16,7 +15,6 @@ Ok(
posonlyargs: [],
args: [
Attributed {
range: 6..7,
custom: (),
node: ArgData {
arg: Identifier(
@ -24,10 +22,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 6..7,
},
},
Attributed {
range: 9..10,
custom: (),
node: ArgData {
arg: Identifier(
@ -35,10 +33,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 9..10,
},
},
Attributed {
range: 12..13,
custom: (),
node: ArgData {
arg: Identifier(
@ -46,13 +44,13 @@ Ok(
),
annotation: None,
type_comment: None,
range: 12..13,
},
},
],
vararg: None,
kwonlyargs: [
Attributed {
range: 18..19,
custom: (),
node: ArgData {
arg: Identifier(
@ -60,10 +58,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 18..19,
},
},
Attributed {
range: 21..22,
custom: (),
node: ArgData {
arg: Identifier(
@ -71,10 +69,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 21..22,
},
},
Attributed {
range: 24..25,
custom: (),
node: ArgData {
arg: Identifier(
@ -82,23 +80,29 @@ Ok(
),
annotation: None,
type_comment: None,
range: 24..25,
},
},
],
kw_defaults: [],
kwarg: None,
defaults: [],
range: 6..25,
},
body: [
Attributed {
range: 28..32,
custom: (),
node: Pass,
node: Pass(
StmtPass {
range: 28..32,
},
),
},
],
decorator_list: [],
returns: None,
type_comment: None,
range: 0..32,
},
),
},

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

@ -5,7 +5,6 @@ expression: parse_ast
Ok(
[
Attributed {
range: 0..38,
custom: (),
node: FunctionDef(
StmtFunctionDef {
@ -16,7 +15,6 @@ Ok(
posonlyargs: [],
args: [
Attributed {
range: 6..7,
custom: (),
node: ArgData {
arg: Identifier(
@ -24,10 +22,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 6..7,
},
},
Attributed {
range: 9..10,
custom: (),
node: ArgData {
arg: Identifier(
@ -35,10 +33,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 9..10,
},
},
Attributed {
range: 12..13,
custom: (),
node: ArgData {
arg: Identifier(
@ -46,13 +44,13 @@ Ok(
),
annotation: None,
type_comment: None,
range: 12..13,
},
},
],
vararg: None,
kwonlyargs: [
Attributed {
range: 18..19,
custom: (),
node: ArgData {
arg: Identifier(
@ -60,10 +58,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 18..19,
},
},
Attributed {
range: 21..22,
custom: (),
node: ArgData {
arg: Identifier(
@ -71,10 +69,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 21..22,
},
},
Attributed {
range: 27..28,
custom: (),
node: ArgData {
arg: Identifier(
@ -82,12 +80,12 @@ Ok(
),
annotation: None,
type_comment: None,
range: 27..28,
},
},
],
kw_defaults: [
Attributed {
range: 23..25,
custom: (),
node: Constant(
ExprConstant {
@ -95,11 +93,11 @@ Ok(
20,
),
kind: None,
range: 23..25,
},
),
},
Attributed {
range: 29..31,
custom: (),
node: Constant(
ExprConstant {
@ -107,23 +105,29 @@ Ok(
30,
),
kind: None,
range: 29..31,
},
),
},
],
kwarg: None,
defaults: [],
range: 6..31,
},
body: [
Attributed {
range: 34..38,
custom: (),
node: Pass,
node: Pass(
StmtPass {
range: 34..38,
},
),
},
],
decorator_list: [],
returns: None,
type_comment: None,
range: 0..38,
},
),
},

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

@ -5,7 +5,6 @@ expression: parse_ast
Ok(
[
Attributed {
range: 0..42,
custom: (),
node: FunctionDef(
StmtFunctionDef {
@ -16,7 +15,6 @@ Ok(
posonlyargs: [],
args: [
Attributed {
range: 6..7,
custom: (),
node: ArgData {
arg: Identifier(
@ -24,10 +22,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 6..7,
},
},
Attributed {
range: 9..10,
custom: (),
node: ArgData {
arg: Identifier(
@ -35,10 +33,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 9..10,
},
},
Attributed {
range: 12..13,
custom: (),
node: ArgData {
arg: Identifier(
@ -46,12 +44,12 @@ Ok(
),
annotation: None,
type_comment: None,
range: 12..13,
},
},
],
vararg: Some(
Attributed {
range: 16..20,
custom: (),
node: ArgData {
arg: Identifier(
@ -59,12 +57,12 @@ Ok(
),
annotation: None,
type_comment: None,
range: 16..20,
},
},
),
kwonlyargs: [
Attributed {
range: 22..23,
custom: (),
node: ArgData {
arg: Identifier(
@ -72,10 +70,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 22..23,
},
},
Attributed {
range: 25..26,
custom: (),
node: ArgData {
arg: Identifier(
@ -83,10 +81,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 25..26,
},
},
Attributed {
range: 31..32,
custom: (),
node: ArgData {
arg: Identifier(
@ -94,12 +92,12 @@ Ok(
),
annotation: None,
type_comment: None,
range: 31..32,
},
},
],
kw_defaults: [
Attributed {
range: 27..29,
custom: (),
node: Constant(
ExprConstant {
@ -107,11 +105,11 @@ Ok(
20,
),
kind: None,
range: 27..29,
},
),
},
Attributed {
range: 33..35,
custom: (),
node: Constant(
ExprConstant {
@ -119,23 +117,29 @@ Ok(
30,
),
kind: None,
range: 33..35,
},
),
},
],
kwarg: None,
defaults: [],
range: 6..35,
},
body: [
Attributed {
range: 38..42,
custom: (),
node: Pass,
node: Pass(
StmtPass {
range: 38..42,
},
),
},
],
decorator_list: [],
returns: None,
type_comment: None,
range: 0..42,
},
),
},

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

@ -5,7 +5,6 @@ expression: parse_ast
Ok(
[
Attributed {
range: 0..52,
custom: (),
node: FunctionDef(
StmtFunctionDef {
@ -16,7 +15,6 @@ Ok(
posonlyargs: [],
args: [
Attributed {
range: 6..7,
custom: (),
node: ArgData {
arg: Identifier(
@ -24,10 +22,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 6..7,
},
},
Attributed {
range: 9..10,
custom: (),
node: ArgData {
arg: Identifier(
@ -35,10 +33,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 9..10,
},
},
Attributed {
range: 12..13,
custom: (),
node: ArgData {
arg: Identifier(
@ -46,12 +44,12 @@ Ok(
),
annotation: None,
type_comment: None,
range: 12..13,
},
},
],
vararg: Some(
Attributed {
range: 16..20,
custom: (),
node: ArgData {
arg: Identifier(
@ -59,12 +57,12 @@ Ok(
),
annotation: None,
type_comment: None,
range: 16..20,
},
},
),
kwonlyargs: [
Attributed {
range: 22..23,
custom: (),
node: ArgData {
arg: Identifier(
@ -72,10 +70,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 22..23,
},
},
Attributed {
range: 25..26,
custom: (),
node: ArgData {
arg: Identifier(
@ -83,10 +81,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 25..26,
},
},
Attributed {
range: 31..32,
custom: (),
node: ArgData {
arg: Identifier(
@ -94,12 +92,12 @@ Ok(
),
annotation: None,
type_comment: None,
range: 31..32,
},
},
],
kw_defaults: [
Attributed {
range: 27..29,
custom: (),
node: Constant(
ExprConstant {
@ -107,11 +105,11 @@ Ok(
20,
),
kind: None,
range: 27..29,
},
),
},
Attributed {
range: 33..35,
custom: (),
node: Constant(
ExprConstant {
@ -119,13 +117,13 @@ Ok(
30,
),
kind: None,
range: 33..35,
},
),
},
],
kwarg: Some(
Attributed {
range: 39..45,
custom: (),
node: ArgData {
arg: Identifier(
@ -133,21 +131,27 @@ Ok(
),
annotation: None,
type_comment: None,
range: 39..45,
},
},
),
defaults: [],
range: 6..45,
},
body: [
Attributed {
range: 48..52,
custom: (),
node: Pass,
node: Pass(
StmtPass {
range: 48..52,
},
),
},
],
decorator_list: [],
returns: None,
type_comment: None,
range: 0..52,
},
),
},

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

@ -5,7 +5,6 @@ expression: parse_ast
Ok(
[
Attributed {
range: 0..20,
custom: (),
node: FunctionDef(
StmtFunctionDef {
@ -16,7 +15,6 @@ Ok(
posonlyargs: [],
args: [
Attributed {
range: 6..7,
custom: (),
node: ArgData {
arg: Identifier(
@ -24,10 +22,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 6..7,
},
},
Attributed {
range: 9..10,
custom: (),
node: ArgData {
arg: Identifier(
@ -35,10 +33,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 9..10,
},
},
Attributed {
range: 12..13,
custom: (),
node: ArgData {
arg: Identifier(
@ -46,6 +44,7 @@ Ok(
),
annotation: None,
type_comment: None,
range: 12..13,
},
},
],
@ -54,17 +53,22 @@ Ok(
kw_defaults: [],
kwarg: None,
defaults: [],
range: 6..13,
},
body: [
Attributed {
range: 16..20,
custom: (),
node: Pass,
node: Pass(
StmtPass {
range: 16..20,
},
),
},
],
decorator_list: [],
returns: None,
type_comment: None,
range: 0..20,
},
),
},

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

@ -5,7 +5,6 @@ expression: parse_ast
Ok(
[
Attributed {
range: 0..26,
custom: (),
node: FunctionDef(
StmtFunctionDef {
@ -16,7 +15,6 @@ Ok(
posonlyargs: [],
args: [
Attributed {
range: 6..7,
custom: (),
node: ArgData {
arg: Identifier(
@ -24,10 +22,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 6..7,
},
},
Attributed {
range: 9..10,
custom: (),
node: ArgData {
arg: Identifier(
@ -35,10 +33,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 9..10,
},
},
Attributed {
range: 15..16,
custom: (),
node: ArgData {
arg: Identifier(
@ -46,6 +44,7 @@ Ok(
),
annotation: None,
type_comment: None,
range: 15..16,
},
},
],
@ -55,7 +54,6 @@ Ok(
kwarg: None,
defaults: [
Attributed {
range: 11..13,
custom: (),
node: Constant(
ExprConstant {
@ -63,11 +61,11 @@ Ok(
20,
),
kind: None,
range: 11..13,
},
),
},
Attributed {
range: 17..19,
custom: (),
node: Constant(
ExprConstant {
@ -75,21 +73,27 @@ Ok(
30,
),
kind: None,
range: 17..19,
},
),
},
],
range: 6..19,
},
body: [
Attributed {
range: 22..26,
custom: (),
node: Pass,
node: Pass(
StmtPass {
range: 22..26,
},
),
},
],
decorator_list: [],
returns: None,
type_comment: None,
range: 0..26,
},
),
},

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

@ -5,12 +5,10 @@ expression: parse_ast
Ok(
[
Attributed {
range: 0..20,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..20,
custom: (),
node: Lambda(
ExprLambda {
@ -20,7 +18,6 @@ Ok(
vararg: None,
kwonlyargs: [
Attributed {
range: 10..11,
custom: (),
node: ArgData {
arg: Identifier(
@ -28,10 +25,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 10..11,
},
},
Attributed {
range: 13..14,
custom: (),
node: ArgData {
arg: Identifier(
@ -39,10 +36,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 13..14,
},
},
Attributed {
range: 16..17,
custom: (),
node: ArgData {
arg: Identifier(
@ -50,15 +47,16 @@ Ok(
),
annotation: None,
type_comment: None,
range: 16..17,
},
},
],
kw_defaults: [],
kwarg: None,
defaults: [],
range: 7..17,
},
body: Attributed {
range: 19..20,
custom: (),
node: Constant(
ExprConstant {
@ -66,12 +64,15 @@ Ok(
1,
),
kind: None,
range: 19..20,
},
),
},
range: 0..20,
},
),
},
range: 0..20,
},
),
},

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

@ -5,12 +5,10 @@ expression: parse_ast
Ok(
[
Attributed {
range: 0..26,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..26,
custom: (),
node: Lambda(
ExprLambda {
@ -20,7 +18,6 @@ Ok(
vararg: None,
kwonlyargs: [
Attributed {
range: 10..11,
custom: (),
node: ArgData {
arg: Identifier(
@ -28,10 +25,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 10..11,
},
},
Attributed {
range: 13..14,
custom: (),
node: ArgData {
arg: Identifier(
@ -39,10 +36,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 13..14,
},
},
Attributed {
range: 19..20,
custom: (),
node: ArgData {
arg: Identifier(
@ -50,12 +47,12 @@ Ok(
),
annotation: None,
type_comment: None,
range: 19..20,
},
},
],
kw_defaults: [
Attributed {
range: 15..17,
custom: (),
node: Constant(
ExprConstant {
@ -63,11 +60,11 @@ Ok(
20,
),
kind: None,
range: 15..17,
},
),
},
Attributed {
range: 21..23,
custom: (),
node: Constant(
ExprConstant {
@ -75,15 +72,16 @@ Ok(
30,
),
kind: None,
range: 21..23,
},
),
},
],
kwarg: None,
defaults: [],
range: 7..23,
},
body: Attributed {
range: 25..26,
custom: (),
node: Constant(
ExprConstant {
@ -91,12 +89,15 @@ Ok(
1,
),
kind: None,
range: 25..26,
},
),
},
range: 0..26,
},
),
},
range: 0..26,
},
),
},

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

@ -5,12 +5,10 @@ expression: parse_ast
Ok(
[
Attributed {
range: 0..9,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..9,
custom: (),
node: Lambda(
ExprLambda {
@ -22,9 +20,9 @@ Ok(
kw_defaults: [],
kwarg: None,
defaults: [],
range: 0..9,
},
body: Attributed {
range: 8..9,
custom: (),
node: Constant(
ExprConstant {
@ -32,12 +30,15 @@ Ok(
1,
),
kind: None,
range: 8..9,
},
),
},
range: 0..9,
},
),
},
range: 0..9,
},
),
},

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

@ -5,12 +5,10 @@ expression: parse_ast
Ok(
[
Attributed {
range: 0..26,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..26,
custom: (),
node: Lambda(
ExprLambda {
@ -18,7 +16,6 @@ Ok(
posonlyargs: [],
args: [
Attributed {
range: 7..8,
custom: (),
node: ArgData {
arg: Identifier(
@ -26,10 +23,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 7..8,
},
},
Attributed {
range: 10..11,
custom: (),
node: ArgData {
arg: Identifier(
@ -37,10 +34,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 10..11,
},
},
Attributed {
range: 13..14,
custom: (),
node: ArgData {
arg: Identifier(
@ -48,13 +45,13 @@ Ok(
),
annotation: None,
type_comment: None,
range: 13..14,
},
},
],
vararg: None,
kwonlyargs: [
Attributed {
range: 19..20,
custom: (),
node: ArgData {
arg: Identifier(
@ -62,10 +59,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 19..20,
},
},
Attributed {
range: 22..23,
custom: (),
node: ArgData {
arg: Identifier(
@ -73,15 +70,16 @@ Ok(
),
annotation: None,
type_comment: None,
range: 22..23,
},
},
],
kw_defaults: [],
kwarg: None,
defaults: [],
range: 7..23,
},
body: Attributed {
range: 25..26,
custom: (),
node: Constant(
ExprConstant {
@ -89,12 +87,15 @@ Ok(
0,
),
kind: None,
range: 25..26,
},
),
},
range: 0..26,
},
),
},
range: 0..26,
},
),
},

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

@ -5,12 +5,10 @@ expression: parse_ast
Ok(
[
Attributed {
range: 0..17,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..17,
custom: (),
node: Lambda(
ExprLambda {
@ -18,7 +16,6 @@ Ok(
posonlyargs: [],
args: [
Attributed {
range: 7..8,
custom: (),
node: ArgData {
arg: Identifier(
@ -26,10 +23,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 7..8,
},
},
Attributed {
range: 10..11,
custom: (),
node: ArgData {
arg: Identifier(
@ -37,10 +34,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 10..11,
},
},
Attributed {
range: 13..14,
custom: (),
node: ArgData {
arg: Identifier(
@ -48,6 +45,7 @@ Ok(
),
annotation: None,
type_comment: None,
range: 13..14,
},
},
],
@ -56,9 +54,9 @@ Ok(
kw_defaults: [],
kwarg: None,
defaults: [],
range: 7..14,
},
body: Attributed {
range: 16..17,
custom: (),
node: Constant(
ExprConstant {
@ -66,12 +64,15 @@ Ok(
1,
),
kind: None,
range: 16..17,
},
),
},
range: 0..17,
},
),
},
range: 0..17,
},
),
},

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

@ -5,12 +5,10 @@ expression: parse_ast
Ok(
[
Attributed {
range: 0..23,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..23,
custom: (),
node: Lambda(
ExprLambda {
@ -18,7 +16,6 @@ Ok(
posonlyargs: [],
args: [
Attributed {
range: 7..8,
custom: (),
node: ArgData {
arg: Identifier(
@ -26,10 +23,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 7..8,
},
},
Attributed {
range: 10..11,
custom: (),
node: ArgData {
arg: Identifier(
@ -37,10 +34,10 @@ Ok(
),
annotation: None,
type_comment: None,
range: 10..11,
},
},
Attributed {
range: 16..17,
custom: (),
node: ArgData {
arg: Identifier(
@ -48,6 +45,7 @@ Ok(
),
annotation: None,
type_comment: None,
range: 16..17,
},
},
],
@ -57,7 +55,6 @@ Ok(
kwarg: None,
defaults: [
Attributed {
range: 12..14,
custom: (),
node: Constant(
ExprConstant {
@ -65,11 +62,11 @@ Ok(
20,
),
kind: None,
range: 12..14,
},
),
},
Attributed {
range: 18..20,
custom: (),
node: Constant(
ExprConstant {
@ -77,13 +74,14 @@ Ok(
30,
),
kind: None,
range: 18..20,
},
),
},
],
range: 7..20,
},
body: Attributed {
range: 22..23,
custom: (),
node: Constant(
ExprConstant {
@ -91,12 +89,15 @@ Ok(
1,
),
kind: None,
range: 22..23,
},
),
},
range: 0..23,
},
),
},
range: 0..23,
},
),
},

12
parser/src/snapshots/rustpython_parser__parser__tests__dict_unpacking.snap generated
View file

@ -3,14 +3,12 @@ source: parser/src/parser.rs
expression: parse_ast
---
Attributed {
range: 0..25,
custom: (),
node: Dict(
ExprDict {
keys: [
Some(
Attributed {
range: 1..4,
custom: (),
node: Constant(
ExprConstant {
@ -18,6 +16,7 @@ Attributed {
"a",
),
kind: None,
range: 1..4,
},
),
},
@ -25,7 +24,6 @@ Attributed {
None,
Some(
Attributed {
range: 16..19,
custom: (),
node: Constant(
ExprConstant {
@ -33,6 +31,7 @@ Attributed {
"d",
),
kind: None,
range: 16..19,
},
),
},
@ -40,7 +39,6 @@ Attributed {
],
values: [
Attributed {
range: 6..9,
custom: (),
node: Constant(
ExprConstant {
@ -48,11 +46,11 @@ Attributed {
"b",
),
kind: None,
range: 6..9,
},
),
},
Attributed {
range: 13..14,
custom: (),
node: Name(
ExprName {
@ -60,11 +58,11 @@ Attributed {
"c",
),
ctx: Load,
range: 13..14,
},
),
},
Attributed {
range: 21..24,
custom: (),
node: Constant(
ExprConstant {
@ -72,10 +70,12 @@ Attributed {
"e",
),
kind: None,
range: 21..24,
},
),
},
],
range: 0..25,
},
),
}

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

@ -3,17 +3,14 @@ source: parser/src/parser.rs
expression: parse_ast
---
Attributed {
range: 0..141,
custom: (),
node: Call(
ExprCall {
func: Attributed {
range: 0..8,
custom: (),
node: Attribute(
ExprAttribute {
value: Attributed {
range: 0..3,
custom: (),
node: Constant(
ExprConstant {
@ -21,6 +18,7 @@ Attributed {
" ",
),
kind: None,
range: 0..3,
},
),
},
@ -28,17 +26,16 @@ Attributed {
"join",
),
ctx: Load,
range: 0..8,
},
),
},
args: [
Attributed {
range: 14..139,
custom: (),
node: GeneratorExp(
ExprGeneratorExp {
elt: Attributed {
range: 14..17,
custom: (),
node: Name(
ExprName {
@ -46,13 +43,13 @@ Attributed {
"sql",
),
ctx: Load,
range: 14..17,
},
),
},
generators: [
Comprehension {
target: Attributed {
range: 26..29,
custom: (),
node: Name(
ExprName {
@ -60,22 +57,20 @@ Attributed {
"sql",
),
ctx: Store,
range: 26..29,
},
),
},
iter: Attributed {
range: 33..139,
custom: (),
node: Tuple(
ExprTuple {
elts: [
Attributed {
range: 43..80,
custom: (),
node: IfExp(
ExprIfExp {
test: Attributed {
range: 65..70,
custom: (),
node: Name(
ExprName {
@ -83,16 +78,15 @@ Attributed {
"limit",
),
ctx: Load,
range: 65..70,
},
),
},
body: Attributed {
range: 43..61,
custom: (),
node: BinOp(
ExprBinOp {
left: Attributed {
range: 43..53,
custom: (),
node: Constant(
ExprConstant {
@ -100,12 +94,12 @@ Attributed {
"LIMIT %d",
),
kind: None,
range: 43..53,
},
),
},
op: Mod,
right: Attributed {
range: 56..61,
custom: (),
node: Name(
ExprName {
@ -113,32 +107,33 @@ Attributed {
"limit",
),
ctx: Load,
range: 56..61,
},
),
},
range: 43..61,
},
),
},
orelse: Attributed {
range: 76..80,
custom: (),
node: Constant(
ExprConstant {
value: None,
kind: None,
range: 76..80,
},
),
},
range: 43..80,
},
),
},
Attributed {
range: 90..132,
custom: (),
node: IfExp(
ExprIfExp {
test: Attributed {
range: 116..122,
custom: (),
node: Name(
ExprName {
@ -146,16 +141,15 @@ Attributed {
"offset",
),
ctx: Load,
range: 116..122,
},
),
},
body: Attributed {
range: 91..111,
custom: (),
node: BinOp(
ExprBinOp {
left: Attributed {
range: 91..102,
custom: (),
node: Constant(
ExprConstant {
@ -163,12 +157,12 @@ Attributed {
"OFFSET %d",
),
kind: None,
range: 91..102,
},
),
},
op: Mod,
right: Attributed {
range: 105..111,
custom: (),
node: Name(
ExprName {
@ -176,39 +170,46 @@ Attributed {
"offset",
),
ctx: Load,
range: 105..111,
},
),
},
range: 91..111,
},
),
},
orelse: Attributed {
range: 128..132,
custom: (),
node: Constant(
ExprConstant {
value: None,
kind: None,
range: 128..132,
},
),
},
range: 90..132,
},
),
},
],
ctx: Load,
range: 33..139,
},
),
},
ifs: [],
is_async: false,
range: 22..139,
},
],
range: 14..139,
},
),
},
],
keywords: [],
range: 0..141,
},
),
}

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

@ -4,19 +4,16 @@ expression: parse_ast
---
[
Attributed {
range: 1..73,
custom: (),
node: Match(
StmtMatch {
subject: Attributed {
range: 7..18,
custom: (),
node: Dict(
ExprDict {
keys: [
Some(
Attributed {
range: 8..14,
custom: (),
node: Constant(
ExprConstant {
@ -24,6 +21,7 @@ expression: parse_ast
"test",
),
kind: None,
range: 8..14,
},
),
},
@ -31,7 +29,6 @@ expression: parse_ast
],
values: [
Attributed {
range: 16..17,
custom: (),
node: Constant(
ExprConstant {
@ -39,17 +36,18 @@ expression: parse_ast
1,
),
kind: None,
range: 16..17,
},
),
},
],
range: 7..18,
},
),
},
cases: [
MatchCase {
pattern: Attributed {
range: 29..52,
custom: (),
node: MatchMapping(
PatternMatchMapping {
@ -60,23 +58,21 @@ expression: parse_ast
"rest",
),
),
range: 29..52,
},
),
},
guard: None,
body: [
Attributed {
range: 62..73,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 62..73,
custom: (),
node: Call(
ExprCall {
func: Attributed {
range: 62..67,
custom: (),
node: Name(
ExprName {
@ -84,12 +80,12 @@ expression: parse_ast
"print",
),
ctx: Load,
range: 62..67,
},
),
},
args: [
Attributed {
range: 68..72,
custom: (),
node: Name(
ExprName {
@ -97,37 +93,39 @@ expression: parse_ast
"rest",
),
ctx: Load,
range: 68..72,
},
),
},
],
keywords: [],
range: 62..73,
},
),
},
range: 62..73,
},
),
},
],
range: 24..74,
},
],
range: 1..73,
},
),
},
Attributed {
range: 74..177,
custom: (),
node: Match(
StmtMatch {
subject: Attributed {
range: 80..97,
custom: (),
node: Dict(
ExprDict {
keys: [
Some(
Attributed {
range: 81..88,
custom: (),
node: Constant(
ExprConstant {
@ -135,6 +133,7 @@ expression: parse_ast
"label",
),
kind: None,
range: 81..88,
},
),
},
@ -142,7 +141,6 @@ expression: parse_ast
],
values: [
Attributed {
range: 90..96,
custom: (),
node: Constant(
ExprConstant {
@ -150,23 +148,23 @@ expression: parse_ast
"test",
),
kind: None,
range: 90..96,
},
),
},
],
range: 80..97,
},
),
},
cases: [
MatchCase {
pattern: Attributed {
range: 108..155,
custom: (),
node: MatchMapping(
PatternMatchMapping {
keys: [
Attributed {
range: 118..125,
custom: (),
node: Constant(
ExprConstant {
@ -174,30 +172,27 @@ expression: parse_ast
"label",
),
kind: None,
range: 118..125,
},
),
},
],
patterns: [
Attributed {
range: 127..148,
custom: (),
node: MatchAs(
PatternMatchAs {
pattern: Some(
Attributed {
range: 127..139,
custom: (),
node: MatchOr(
PatternMatchOr {
patterns: [
Attributed {
range: 127..132,
custom: (),
node: MatchClass(
PatternMatchClass {
cls: Attributed {
range: 127..130,
custom: (),
node: Name(
ExprName {
@ -205,25 +200,28 @@ expression: parse_ast
"str",
),
ctx: Load,
range: 127..130,
},
),
},
patterns: [],
kwd_attrs: [],
kwd_patterns: [],
range: 127..132,
},
),
},
Attributed {
range: 135..139,
custom: (),
node: MatchSingleton(
PatternMatchSingleton {
value: None,
range: 135..139,
},
),
},
],
range: 127..139,
},
),
},
@ -233,28 +231,27 @@ expression: parse_ast
"label",
),
),
range: 127..148,
},
),
},
],
rest: None,
range: 108..155,
},
),
},
guard: None,
body: [
Attributed {
range: 165..177,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 165..177,
custom: (),
node: Call(
ExprCall {
func: Attributed {
range: 165..170,
custom: (),
node: Name(
ExprName {
@ -262,12 +259,12 @@ expression: parse_ast
"print",
),
ctx: Load,
range: 165..170,
},
),
},
args: [
Attributed {
range: 171..176,
custom: (),
node: Name(
ExprName {
@ -275,30 +272,33 @@ expression: parse_ast
"label",
),
ctx: Load,
range: 171..176,
},
),
},
],
keywords: [],
range: 165..177,
},
),
},
range: 165..177,
},
),
},
],
range: 103..178,
},
],
range: 74..177,
},
),
},
Attributed {
range: 178..218,
custom: (),
node: Match(
StmtMatch {
subject: Attributed {
range: 184..185,
custom: (),
node: Name(
ExprName {
@ -306,24 +306,22 @@ expression: parse_ast
"x",
),
ctx: Load,
range: 184..185,
},
),
},
cases: [
MatchCase {
pattern: Attributed {
range: 196..203,
custom: (),
node: MatchSequence(
PatternMatchSequence {
patterns: [
Attributed {
range: 197..198,
custom: (),
node: MatchValue(
PatternMatchValue {
value: Attributed {
range: 197..198,
custom: (),
node: Constant(
ExprConstant {
@ -331,19 +329,19 @@ expression: parse_ast
0,
),
kind: None,
range: 197..198,
},
),
},
range: 197..198,
},
),
},
Attributed {
range: 200..201,
custom: (),
node: MatchValue(
PatternMatchValue {
value: Attributed {
range: 200..201,
custom: (),
node: Constant(
ExprConstant {
@ -351,26 +349,27 @@ expression: parse_ast
1,
),
kind: None,
range: 200..201,
},
),
},
range: 200..201,
},
),
},
],
range: 196..203,
},
),
},
guard: None,
body: [
Attributed {
range: 213..218,
custom: (),
node: Assign(
StmtAssign {
targets: [
Attributed {
range: 213..214,
custom: (),
node: Name(
ExprName {
@ -378,12 +377,12 @@ expression: parse_ast
"y",
),
ctx: Store,
range: 213..214,
},
),
},
],
value: Attributed {
range: 217..218,
custom: (),
node: Constant(
ExprConstant {
@ -391,26 +390,28 @@ expression: parse_ast
0,
),
kind: None,
range: 217..218,
},
),
},
type_comment: None,
range: 213..218,
},
),
},
],
range: 191..219,
},
],
range: 178..218,
},
),
},
Attributed {
range: 219..259,
custom: (),
node: Match(
StmtMatch {
subject: Attributed {
range: 225..226,
custom: (),
node: Name(
ExprName {
@ -418,24 +419,22 @@ expression: parse_ast
"x",
),
ctx: Load,
range: 225..226,
},
),
},
cases: [
MatchCase {
pattern: Attributed {
range: 237..244,
custom: (),
node: MatchSequence(
PatternMatchSequence {
patterns: [
Attributed {
range: 238..239,
custom: (),
node: MatchValue(
PatternMatchValue {
value: Attributed {
range: 238..239,
custom: (),
node: Constant(
ExprConstant {
@ -443,19 +442,19 @@ expression: parse_ast
0,
),
kind: None,
range: 238..239,
},
),
},
range: 238..239,
},
),
},
Attributed {
range: 241..242,
custom: (),
node: MatchValue(
PatternMatchValue {
value: Attributed {
range: 241..242,
custom: (),
node: Constant(
ExprConstant {
@ -463,26 +462,27 @@ expression: parse_ast
1,
),
kind: None,
range: 241..242,
},
),
},
range: 241..242,
},
),
},
],
range: 237..244,
},
),
},
guard: None,
body: [
Attributed {
range: 254..259,
custom: (),
node: Assign(
StmtAssign {
targets: [
Attributed {
range: 254..255,
custom: (),
node: Name(
ExprName {
@ -490,12 +490,12 @@ expression: parse_ast
"y",
),
ctx: Store,
range: 254..255,
},
),
},
],
value: Attributed {
range: 258..259,
custom: (),
node: Constant(
ExprConstant {
@ -503,26 +503,28 @@ expression: parse_ast
0,
),
kind: None,
range: 258..259,
},
),
},
type_comment: None,
range: 254..259,
},
),
},
],
range: 232..260,
},
],
range: 219..259,
},
),
},
Attributed {
range: 260..297,
custom: (),
node: Match(
StmtMatch {
subject: Attributed {
range: 266..267,
custom: (),
node: Name(
ExprName {
@ -530,24 +532,22 @@ expression: parse_ast
"x",
),
ctx: Load,
range: 266..267,
},
),
},
cases: [
MatchCase {
pattern: Attributed {
range: 278..282,
custom: (),
node: MatchSequence(
PatternMatchSequence {
patterns: [
Attributed {
range: 279..280,
custom: (),
node: MatchValue(
PatternMatchValue {
value: Attributed {
range: 279..280,
custom: (),
node: Constant(
ExprConstant {
@ -555,26 +555,27 @@ expression: parse_ast
0,
),
kind: None,
range: 279..280,
},
),
},
range: 279..280,
},
),
},
],
range: 278..282,
},
),
},
guard: None,
body: [
Attributed {
range: 292..297,
custom: (),
node: Assign(
StmtAssign {
targets: [
Attributed {
range: 292..293,
custom: (),
node: Name(
ExprName {
@ -582,12 +583,12 @@ expression: parse_ast
"y",
),
ctx: Store,
range: 292..293,
},
),
},
],
value: Attributed {
range: 296..297,
custom: (),
node: Constant(
ExprConstant {
@ -595,16 +596,20 @@ expression: parse_ast
0,
),
kind: None,
range: 296..297,
},
),
},
type_comment: None,
range: 292..297,
},
),
},
],
range: 273..298,
},
],
range: 260..297,
},
),
},

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

File diff suppressed because it is too large Load diff

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

@ -3,14 +3,12 @@ source: parser/src/parser.rs
expression: parse_ast
---
Attributed {
range: 0..7,
custom: (),
node: BoolOp(
ExprBoolOp {
op: And,
values: [
Attributed {
range: 0..1,
custom: (),
node: Name(
ExprName {
@ -18,11 +16,11 @@ Attributed {
"x",
),
ctx: Load,
range: 0..1,
},
),
},
Attributed {
range: 6..7,
custom: (),
node: Name(
ExprName {
@ -30,10 +28,12 @@ Attributed {
"y",
),
ctx: Load,
range: 6..7,
},
),
},
],
range: 0..7,
},
),
}

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

@ -3,14 +3,12 @@ source: parser/src/parser.rs
expression: parse_ast
---
Attributed {
range: 0..6,
custom: (),
node: BoolOp(
ExprBoolOp {
op: Or,
values: [
Attributed {
range: 0..1,
custom: (),
node: Name(
ExprName {
@ -18,11 +16,11 @@ Attributed {
"x",
),
ctx: Load,
range: 0..1,
},
),
},
Attributed {
range: 5..6,
custom: (),
node: Name(
ExprName {
@ -30,10 +28,12 @@ Attributed {
"y",
),
ctx: Load,
range: 5..6,
},
),
},
],
range: 0..6,
},
),
}

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

@ -4,7 +4,6 @@ expression: "parse_program(source, \"<test>\").unwrap()"
---
[
Attributed {
range: 0..98,
custom: (),
node: ClassDef(
StmtClassDef {
@ -13,7 +12,6 @@ expression: "parse_program(source, \"<test>\").unwrap()"
),
bases: [
Attributed {
range: 10..11,
custom: (),
node: Name(
ExprName {
@ -21,11 +19,11 @@ expression: "parse_program(source, \"<test>\").unwrap()"
"A",
),
ctx: Load,
range: 10..11,
},
),
},
Attributed {
range: 13..14,
custom: (),
node: Name(
ExprName {
@ -33,6 +31,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
"B",
),
ctx: Load,
range: 13..14,
},
),
},
@ -40,7 +39,6 @@ expression: "parse_program(source, \"<test>\").unwrap()"
keywords: [],
body: [
Attributed {
range: 18..44,
custom: (),
node: FunctionDef(
StmtFunctionDef {
@ -51,7 +49,6 @@ expression: "parse_program(source, \"<test>\").unwrap()"
posonlyargs: [],
args: [
Attributed {
range: 31..35,
custom: (),
node: ArgData {
arg: Identifier(
@ -59,6 +56,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
),
annotation: None,
type_comment: None,
range: 31..35,
},
},
],
@ -67,22 +65,26 @@ expression: "parse_program(source, \"<test>\").unwrap()"
kw_defaults: [],
kwarg: None,
defaults: [],
range: 31..35,
},
body: [
Attributed {
range: 40..44,
custom: (),
node: Pass,
node: Pass(
StmtPass {
range: 40..44,
},
),
},
],
decorator_list: [],
returns: None,
type_comment: None,
range: 18..44,
},
),
},
Attributed {
range: 46..98,
custom: (),
node: FunctionDef(
StmtFunctionDef {
@ -93,7 +95,6 @@ expression: "parse_program(source, \"<test>\").unwrap()"
posonlyargs: [],
args: [
Attributed {
range: 70..74,
custom: (),
node: ArgData {
arg: Identifier(
@ -101,10 +102,10 @@ expression: "parse_program(source, \"<test>\").unwrap()"
),
annotation: None,
type_comment: None,
range: 70..74,
},
},
Attributed {
range: 76..79,
custom: (),
node: ArgData {
arg: Identifier(
@ -112,6 +113,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
),
annotation: None,
type_comment: None,
range: 76..79,
},
},
],
@ -121,7 +123,6 @@ expression: "parse_program(source, \"<test>\").unwrap()"
kwarg: None,
defaults: [
Attributed {
range: 80..89,
custom: (),
node: Constant(
ExprConstant {
@ -129,26 +130,33 @@ expression: "parse_program(source, \"<test>\").unwrap()"
"default",
),
kind: None,
range: 80..89,
},
),
},
],
range: 70..89,
},
body: [
Attributed {
range: 94..98,
custom: (),
node: Pass,
node: Pass(
StmtPass {
range: 94..98,
},
),
},
],
decorator_list: [],
returns: None,
type_comment: None,
range: 46..98,
},
),
},
],
decorator_list: [],
range: 0..98,
},
),
},

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

@ -3,12 +3,10 @@ source: parser/src/parser.rs
expression: parse_ast
---
Attributed {
range: 0..19,
custom: (),
node: DictComp(
ExprDictComp {
key: Attributed {
range: 1..3,
custom: (),
node: Name(
ExprName {
@ -16,11 +14,11 @@ Attributed {
"x1",
),
ctx: Load,
range: 1..3,
},
),
},
value: Attributed {
range: 5..7,
custom: (),
node: Name(
ExprName {
@ -28,13 +26,13 @@ Attributed {
"x2",
),
ctx: Load,
range: 5..7,
},
),
},
generators: [
Comprehension {
target: Attributed {
range: 12..13,
custom: (),
node: Name(
ExprName {
@ -42,11 +40,11 @@ Attributed {
"y",
),
ctx: Store,
range: 12..13,
},
),
},
iter: Attributed {
range: 17..18,
custom: (),
node: Name(
ExprName {
@ -54,13 +52,16 @@ Attributed {
"z",
),
ctx: Load,
range: 17..18,
},
),
},
ifs: [],
is_async: false,
range: 8..18,
},
],
range: 0..19,
},
),
}

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

@ -3,12 +3,10 @@ source: parser/src/parser.rs
expression: parse_ast
---
Attributed {
range: 0..48,
custom: (),
node: ListComp(
ExprListComp {
elt: Attributed {
range: 1..2,
custom: (),
node: Name(
ExprName {
@ -16,19 +14,18 @@ Attributed {
"x",
),
ctx: Load,
range: 1..2,
},
),
},
generators: [
Comprehension {
target: Attributed {
range: 7..12,
custom: (),
node: Tuple(
ExprTuple {
elts: [
Attributed {
range: 7..8,
custom: (),
node: Name(
ExprName {
@ -36,11 +33,11 @@ Attributed {
"y",
),
ctx: Store,
range: 7..8,
},
),
},
Attributed {
range: 10..12,
custom: (),
node: Name(
ExprName {
@ -48,16 +45,17 @@ Attributed {
"y2",
),
ctx: Store,
range: 10..12,
},
),
},
],
ctx: Store,
range: 7..12,
},
),
},
iter: Attributed {
range: 16..17,
custom: (),
node: Name(
ExprName {
@ -65,15 +63,16 @@ Attributed {
"z",
),
ctx: Load,
range: 16..17,
},
),
},
ifs: [],
is_async: false,
range: 3..17,
},
Comprehension {
target: Attributed {
range: 22..23,
custom: (),
node: Name(
ExprName {
@ -81,11 +80,11 @@ Attributed {
"a",
),
ctx: Store,
range: 22..23,
},
),
},
iter: Attributed {
range: 27..28,
custom: (),
node: Name(
ExprName {
@ -93,17 +92,16 @@ Attributed {
"b",
),
ctx: Load,
range: 27..28,
},
),
},
ifs: [
Attributed {
range: 32..37,
custom: (),
node: Compare(
ExprCompare {
left: Attributed {
range: 32..33,
custom: (),
node: Name(
ExprName {
@ -111,6 +109,7 @@ Attributed {
"a",
),
ctx: Load,
range: 32..33,
},
),
},
@ -119,7 +118,6 @@ Attributed {
],
comparators: [
Attributed {
range: 36..37,
custom: (),
node: Constant(
ExprConstant {
@ -127,20 +125,20 @@ Attributed {
5,
),
kind: None,
range: 36..37,
},
),
},
],
range: 32..37,
},
),
},
Attributed {
range: 41..47,
custom: (),
node: Compare(
ExprCompare {
left: Attributed {
range: 41..42,
custom: (),
node: Name(
ExprName {
@ -148,6 +146,7 @@ Attributed {
"a",
),
ctx: Load,
range: 41..42,
},
),
},
@ -156,7 +155,6 @@ Attributed {
],
comparators: [
Attributed {
range: 45..47,
custom: (),
node: Constant(
ExprConstant {
@ -164,17 +162,21 @@ Attributed {
10,
),
kind: None,
range: 45..47,
},
),
},
],
range: 41..47,
},
),
},
],
is_async: false,
range: 18..47,
},
],
range: 0..48,
},
),
}

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

@ -4,18 +4,15 @@ expression: parse_ast
---
[
Attributed {
range: 0..14,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..14,
custom: (),
node: JoinedStr(
ExprJoinedStr {
values: [
Attributed {
range: 0..14,
custom: (),
node: Constant(
ExprConstant {
@ -23,13 +20,16 @@ expression: parse_ast
"Hello world",
),
kind: None,
range: 0..14,
},
),
},
],
range: 0..14,
},
),
},
range: 0..14,
},
),
},

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

@ -3,12 +3,10 @@ source: parser/src/parser.rs
expression: parse_ast
---
Attributed {
range: 0..14,
custom: (),
node: GeneratorExp(
ExprGeneratorExp {
elt: Attributed {
range: 1..2,
custom: (),
node: Name(
ExprName {
@ -16,13 +14,13 @@ Attributed {
"x",
),
ctx: Load,
range: 1..2,
},
),
},
generators: [
Comprehension {
target: Attributed {
range: 7..8,
custom: (),
node: Name(
ExprName {
@ -30,11 +28,11 @@ Attributed {
"y",
),
ctx: Store,
range: 7..8,
},
),
},
iter: Attributed {
range: 12..13,
custom: (),
node: Name(
ExprName {
@ -42,13 +40,16 @@ Attributed {
"z",
),
ctx: Load,
range: 12..13,
},
),
},
ifs: [],
is_async: false,
range: 3..13,
},
],
range: 0..14,
},
),
}

20
parser/src/snapshots/rustpython_parser__parser__tests__parse_if_elif_else.snap generated
View file

@ -4,12 +4,10 @@ expression: parse_ast
---
[
Attributed {
range: 0..28,
custom: (),
node: If(
StmtIf {
test: Attributed {
range: 3..4,
custom: (),
node: Constant(
ExprConstant {
@ -17,17 +15,16 @@ expression: parse_ast
1,
),
kind: None,
range: 3..4,
},
),
},
body: [
Attributed {
range: 6..8,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 6..8,
custom: (),
node: Constant(
ExprConstant {
@ -35,21 +32,21 @@ expression: parse_ast
10,
),
kind: None,
range: 6..8,
},
),
},
range: 6..8,
},
),
},
],
orelse: [
Attributed {
range: 9..28,
custom: (),
node: If(
StmtIf {
test: Attributed {
range: 14..15,
custom: (),
node: Constant(
ExprConstant {
@ -57,17 +54,16 @@ expression: parse_ast
2,
),
kind: None,
range: 14..15,
},
),
},
body: [
Attributed {
range: 17..19,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 17..19,
custom: (),
node: Constant(
ExprConstant {
@ -75,21 +71,21 @@ expression: parse_ast
20,
),
kind: None,
range: 17..19,
},
),
},
range: 17..19,
},
),
},
],
orelse: [
Attributed {
range: 26..28,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 26..28,
custom: (),
node: Constant(
ExprConstant {
@ -97,17 +93,21 @@ expression: parse_ast
30,
),
kind: None,
range: 26..28,
},
),
},
range: 26..28,
},
),
},
],
range: 9..28,
},
),
},
],
range: 0..28,
},
),
},

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

@ -3,17 +3,14 @@ source: parser/src/parser.rs
expression: parse_ast
---
Attributed {
range: 0..26,
custom: (),
node: GeneratorExp(
ExprGeneratorExp {
elt: Attributed {
range: 1..14,
custom: (),
node: IfExp(
ExprIfExp {
test: Attributed {
range: 6..7,
custom: (),
node: Name(
ExprName {
@ -21,11 +18,11 @@ Attributed {
"y",
),
ctx: Load,
range: 6..7,
},
),
},
body: Attributed {
range: 1..2,
custom: (),
node: Name(
ExprName {
@ -33,11 +30,11 @@ Attributed {
"x",
),
ctx: Load,
range: 1..2,
},
),
},
orelse: Attributed {
range: 13..14,
custom: (),
node: Name(
ExprName {
@ -45,16 +42,17 @@ Attributed {
"y",
),
ctx: Load,
range: 13..14,
},
),
},
range: 1..14,
},
),
},
generators: [
Comprehension {
target: Attributed {
range: 19..20,
custom: (),
node: Name(
ExprName {
@ -62,11 +60,11 @@ Attributed {
"y",
),
ctx: Store,
range: 19..20,
},
),
},
iter: Attributed {
range: 24..25,
custom: (),
node: Name(
ExprName {
@ -74,13 +72,16 @@ Attributed {
"z",
),
ctx: Load,
range: 24..25,
},
),
},
ifs: [],
is_async: false,
range: 15..25,
},
],
range: 0..26,
},
),
}

12
parser/src/snapshots/rustpython_parser__parser__tests__parse_kwargs.snap generated
View file

@ -4,17 +4,14 @@ expression: parse_ast
---
[
Attributed {
range: 0..32,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..32,
custom: (),
node: Call(
ExprCall {
func: Attributed {
range: 0..7,
custom: (),
node: Name(
ExprName {
@ -22,12 +19,12 @@ expression: parse_ast
"my_func",
),
ctx: Load,
range: 0..7,
},
),
},
args: [
Attributed {
range: 8..20,
custom: (),
node: Constant(
ExprConstant {
@ -35,13 +32,13 @@ expression: parse_ast
"positional",
),
kind: None,
range: 8..20,
},
),
},
],
keywords: [
Attributed {
range: 22..31,
custom: (),
node: KeywordData {
arg: Some(
@ -50,7 +47,6 @@ expression: parse_ast
),
),
value: Attributed {
range: 30..31,
custom: (),
node: Constant(
ExprConstant {
@ -58,15 +54,19 @@ expression: parse_ast
2,
),
kind: None,
range: 30..31,
},
),
},
range: 22..31,
},
},
],
range: 0..32,
},
),
},
range: 0..32,
},
),
},

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

@ -4,12 +4,10 @@ expression: parse_ast
---
[
Attributed {
range: 0..18,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..18,
custom: (),
node: Lambda(
ExprLambda {
@ -17,7 +15,6 @@ expression: parse_ast
posonlyargs: [],
args: [
Attributed {
range: 7..8,
custom: (),
node: ArgData {
arg: Identifier(
@ -25,10 +22,10 @@ expression: parse_ast
),
annotation: None,
type_comment: None,
range: 7..8,
},
},
Attributed {
range: 10..11,
custom: (),
node: ArgData {
arg: Identifier(
@ -36,6 +33,7 @@ expression: parse_ast
),
annotation: None,
type_comment: None,
range: 10..11,
},
},
],
@ -44,14 +42,13 @@ expression: parse_ast
kw_defaults: [],
kwarg: None,
defaults: [],
range: 7..11,
},
body: Attributed {
range: 13..18,
custom: (),
node: BinOp(
ExprBinOp {
left: Attributed {
range: 13..14,
custom: (),
node: Name(
ExprName {
@ -59,12 +56,12 @@ expression: parse_ast
"x",
),
ctx: Load,
range: 13..14,
},
),
},
op: Mult,
right: Attributed {
range: 17..18,
custom: (),
node: Name(
ExprName {
@ -72,15 +69,19 @@ expression: parse_ast
"y",
),
ctx: Load,
range: 17..18,
},
),
},
range: 13..18,
},
),
},
range: 0..18,
},
),
},
range: 0..18,
},
),
},

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

@ -3,12 +3,10 @@ source: parser/src/parser.rs
expression: parse_ast
---
Attributed {
range: 0..14,
custom: (),
node: ListComp(
ExprListComp {
elt: Attributed {
range: 1..2,
custom: (),
node: Name(
ExprName {
@ -16,13 +14,13 @@ Attributed {
"x",
),
ctx: Load,
range: 1..2,
},
),
},
generators: [
Comprehension {
target: Attributed {
range: 7..8,
custom: (),
node: Name(
ExprName {
@ -30,11 +28,11 @@ Attributed {
"y",
),
ctx: Store,
range: 7..8,
},
),
},
iter: Attributed {
range: 12..13,
custom: (),
node: Name(
ExprName {
@ -42,13 +40,16 @@ Attributed {
"z",
),
ctx: Load,
range: 12..13,
},
),
},
ifs: [],
is_async: false,
range: 3..13,
},
],
range: 0..14,
},
),
}

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

@ -3,17 +3,14 @@ source: parser/src/parser.rs
expression: parse_ast
---
Attributed {
range: 0..23,
custom: (),
node: GeneratorExp(
ExprGeneratorExp {
elt: Attributed {
range: 1..11,
custom: (),
node: NamedExpr(
ExprNamedExpr {
target: Attributed {
range: 1..2,
custom: (),
node: Name(
ExprName {
@ -21,16 +18,15 @@ Attributed {
"x",
),
ctx: Store,
range: 1..2,
},
),
},
value: Attributed {
range: 6..11,
custom: (),
node: BinOp(
ExprBinOp {
left: Attributed {
range: 6..7,
custom: (),
node: Name(
ExprName {
@ -38,12 +34,12 @@ Attributed {
"y",
),
ctx: Load,
range: 6..7,
},
),
},
op: Add,
right: Attributed {
range: 10..11,
custom: (),
node: Constant(
ExprConstant {
@ -51,19 +47,21 @@ Attributed {
1,
),
kind: None,
range: 10..11,
},
),
},
range: 6..11,
},
),
},
range: 1..11,
},
),
},
generators: [
Comprehension {
target: Attributed {
range: 16..17,
custom: (),
node: Name(
ExprName {
@ -71,11 +69,11 @@ Attributed {
"y",
),
ctx: Store,
range: 16..17,
},
),
},
iter: Attributed {
range: 21..22,
custom: (),
node: Name(
ExprName {
@ -83,13 +81,16 @@ Attributed {
"z",
),
ctx: Load,
range: 21..22,
},
),
},
ifs: [],
is_async: false,
range: 12..22,
},
],
range: 0..23,
},
),
}

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

@ -4,17 +4,14 @@ expression: parse_ast
---
[
Attributed {
range: 0..23,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..23,
custom: (),
node: Call(
ExprCall {
func: Attributed {
range: 0..5,
custom: (),
node: Name(
ExprName {
@ -22,12 +19,12 @@ expression: parse_ast
"print",
),
ctx: Load,
range: 0..5,
},
),
},
args: [
Attributed {
range: 6..19,
custom: (),
node: Constant(
ExprConstant {
@ -35,11 +32,11 @@ expression: parse_ast
"Hello world",
),
kind: None,
range: 6..19,
},
),
},
Attributed {
range: 21..22,
custom: (),
node: Constant(
ExprConstant {
@ -47,14 +44,17 @@ expression: parse_ast
2,
),
kind: None,
range: 21..22,
},
),
},
],
keywords: [],
range: 0..23,
},
),
},
range: 0..23,
},
),
},

8
parser/src/snapshots/rustpython_parser__parser__tests__parse_print_hello.snap generated
View file

@ -4,17 +4,14 @@ expression: parse_ast
---
[
Attributed {
range: 0..20,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..20,
custom: (),
node: Call(
ExprCall {
func: Attributed {
range: 0..5,
custom: (),
node: Name(
ExprName {
@ -22,12 +19,12 @@ expression: parse_ast
"print",
),
ctx: Load,
range: 0..5,
},
),
},
args: [
Attributed {
range: 6..19,
custom: (),
node: Constant(
ExprConstant {
@ -35,14 +32,17 @@ expression: parse_ast
"Hello world",
),
kind: None,
range: 6..19,
},
),
},
],
keywords: [],
range: 0..20,
},
),
},
range: 0..20,
},
),
},

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

@ -4,12 +4,10 @@ expression: parse_ast
---
[
Attributed {
range: 0..13,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..13,
custom: (),
node: Constant(
ExprConstant {
@ -17,9 +15,11 @@ expression: parse_ast
"Hello world",
),
kind: None,
range: 0..13,
},
),
},
range: 0..13,
},
),
},

14
parser/src/snapshots/rustpython_parser__parser__tests__parse_tuples.snap generated
View file

@ -4,19 +4,16 @@ expression: "parse_program(source, \"<test>\").unwrap()"
---
[
Attributed {
range: 0..11,
custom: (),
node: Assign(
StmtAssign {
targets: [
Attributed {
range: 0..4,
custom: (),
node: Tuple(
ExprTuple {
elts: [
Attributed {
range: 0..1,
custom: (),
node: Name(
ExprName {
@ -24,11 +21,11 @@ expression: "parse_program(source, \"<test>\").unwrap()"
"a",
),
ctx: Store,
range: 0..1,
},
),
},
Attributed {
range: 3..4,
custom: (),
node: Name(
ExprName {
@ -36,23 +33,23 @@ expression: "parse_program(source, \"<test>\").unwrap()"
"b",
),
ctx: Store,
range: 3..4,
},
),
},
],
ctx: Store,
range: 0..4,
},
),
},
],
value: Attributed {
range: 7..11,
custom: (),
node: Tuple(
ExprTuple {
elts: [
Attributed {
range: 7..8,
custom: (),
node: Constant(
ExprConstant {
@ -60,11 +57,11 @@ expression: "parse_program(source, \"<test>\").unwrap()"
4,
),
kind: None,
range: 7..8,
},
),
},
Attributed {
range: 10..11,
custom: (),
node: Constant(
ExprConstant {
@ -72,15 +69,18 @@ expression: "parse_program(source, \"<test>\").unwrap()"
5,
),
kind: None,
range: 10..11,
},
),
},
],
ctx: Load,
range: 7..11,
},
),
},
type_comment: None,
range: 0..11,
},
),
},

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

File diff suppressed because it is too large Load diff

12
parser/src/snapshots/rustpython_parser__parser__tests__slice.snap generated
View file

@ -3,12 +3,10 @@ source: parser/src/parser.rs
expression: parse_ast
---
Attributed {
range: 0..8,
custom: (),
node: Subscript(
ExprSubscript {
value: Attributed {
range: 0..1,
custom: (),
node: Name(
ExprName {
@ -16,17 +14,16 @@ Attributed {
"x",
),
ctx: Load,
range: 0..1,
},
),
},
slice: Attributed {
range: 2..7,
custom: (),
node: Slice(
ExprSlice {
lower: Some(
Attributed {
range: 2..3,
custom: (),
node: Constant(
ExprConstant {
@ -34,13 +31,13 @@ Attributed {
1,
),
kind: None,
range: 2..3,
},
),
},
),
upper: Some(
Attributed {
range: 4..5,
custom: (),
node: Constant(
ExprConstant {
@ -48,13 +45,13 @@ Attributed {
2,
),
kind: None,
range: 4..5,
},
),
},
),
step: Some(
Attributed {
range: 6..7,
custom: (),
node: Constant(
ExprConstant {
@ -62,14 +59,17 @@ Attributed {
3,
),
kind: None,
range: 6..7,
},
),
},
),
range: 2..7,
},
),
},
ctx: Load,
range: 0..8,
},
),
}

74
parser/src/snapshots/rustpython_parser__parser__tests__star_index.snap generated
View file

@ -4,13 +4,11 @@ expression: parse_ast
---
[
Attributed {
range: 0..36,
custom: (),
node: Assign(
StmtAssign {
targets: [
Attributed {
range: 0..11,
custom: (),
node: Name(
ExprName {
@ -18,17 +16,16 @@ expression: parse_ast
"array_slice",
),
ctx: Store,
range: 0..11,
},
),
},
],
value: Attributed {
range: 14..36,
custom: (),
node: Subscript(
ExprSubscript {
value: Attributed {
range: 14..19,
custom: (),
node: Name(
ExprName {
@ -36,17 +33,16 @@ expression: parse_ast
"array",
),
ctx: Load,
range: 14..19,
},
),
},
slice: Attributed {
range: 20..35,
custom: (),
node: Tuple(
ExprTuple {
elts: [
Attributed {
range: 20..21,
custom: (),
node: Constant(
ExprConstant {
@ -54,16 +50,15 @@ expression: parse_ast
0,
),
kind: None,
range: 20..21,
},
),
},
Attributed {
range: 23..31,
custom: (),
node: Starred(
ExprStarred {
value: Attributed {
range: 24..31,
custom: (),
node: Name(
ExprName {
@ -71,21 +66,21 @@ expression: parse_ast
"indexes",
),
ctx: Load,
range: 24..31,
},
),
},
ctx: Load,
range: 23..31,
},
),
},
Attributed {
range: 33..35,
custom: (),
node: UnaryOp(
ExprUnaryOp {
op: USub,
operand: Attributed {
range: 34..35,
custom: (),
node: Constant(
ExprConstant {
@ -93,38 +88,40 @@ expression: parse_ast
1,
),
kind: None,
range: 34..35,
},
),
},
range: 33..35,
},
),
},
],
ctx: Load,
range: 20..35,
},
),
},
ctx: Load,
range: 14..36,
},
),
},
type_comment: None,
range: 0..36,
},
),
},
Attributed {
range: 37..73,
custom: (),
node: Assign(
StmtAssign {
targets: [
Attributed {
range: 37..59,
custom: (),
node: Subscript(
ExprSubscript {
value: Attributed {
range: 37..42,
custom: (),
node: Name(
ExprName {
@ -132,17 +129,16 @@ expression: parse_ast
"array",
),
ctx: Load,
range: 37..42,
},
),
},
slice: Attributed {
range: 43..58,
custom: (),
node: Tuple(
ExprTuple {
elts: [
Attributed {
range: 43..44,
custom: (),
node: Constant(
ExprConstant {
@ -150,16 +146,15 @@ expression: parse_ast
0,
),
kind: None,
range: 43..44,
},
),
},
Attributed {
range: 46..54,
custom: (),
node: Starred(
ExprStarred {
value: Attributed {
range: 47..54,
custom: (),
node: Name(
ExprName {
@ -167,21 +162,21 @@ expression: parse_ast
"indexes",
),
ctx: Load,
range: 47..54,
},
),
},
ctx: Load,
range: 46..54,
},
),
},
Attributed {
range: 56..58,
custom: (),
node: UnaryOp(
ExprUnaryOp {
op: USub,
operand: Attributed {
range: 57..58,
custom: (),
node: Constant(
ExprConstant {
@ -189,24 +184,27 @@ expression: parse_ast
1,
),
kind: None,
range: 57..58,
},
),
},
range: 56..58,
},
),
},
],
ctx: Load,
range: 43..58,
},
),
},
ctx: Store,
range: 37..59,
},
),
},
],
value: Attributed {
range: 62..73,
custom: (),
node: Name(
ExprName {
@ -214,25 +212,24 @@ expression: parse_ast
"array_slice",
),
ctx: Load,
range: 62..73,
},
),
},
type_comment: None,
range: 37..73,
},
),
},
Attributed {
range: 74..119,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 74..119,
custom: (),
node: Subscript(
ExprSubscript {
value: Attributed {
range: 74..79,
custom: (),
node: Name(
ExprName {
@ -240,22 +237,20 @@ expression: parse_ast
"array",
),
ctx: Load,
range: 74..79,
},
),
},
slice: Attributed {
range: 80..118,
custom: (),
node: Tuple(
ExprTuple {
elts: [
Attributed {
range: 80..98,
custom: (),
node: Starred(
ExprStarred {
value: Attributed {
range: 81..98,
custom: (),
node: Name(
ExprName {
@ -263,20 +258,20 @@ expression: parse_ast
"indexes_to_select",
),
ctx: Load,
range: 81..98,
},
),
},
ctx: Load,
range: 80..98,
},
),
},
Attributed {
range: 100..118,
custom: (),
node: Starred(
ExprStarred {
value: Attributed {
range: 101..118,
custom: (),
node: Name(
ExprName {
@ -284,37 +279,39 @@ expression: parse_ast
"indexes_to_select",
),
ctx: Load,
range: 101..118,
},
),
},
ctx: Load,
range: 100..118,
},
),
},
],
ctx: Load,
range: 80..118,
},
),
},
ctx: Load,
range: 74..119,
},
),
},
range: 74..119,
},
),
},
Attributed {
range: 120..150,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 120..150,
custom: (),
node: Subscript(
ExprSubscript {
value: Attributed {
range: 120..125,
custom: (),
node: Name(
ExprName {
@ -322,23 +319,21 @@ expression: parse_ast
"array",
),
ctx: Load,
range: 120..125,
},
),
},
slice: Attributed {
range: 126..149,
custom: (),
node: Tuple(
ExprTuple {
elts: [
Attributed {
range: 126..129,
custom: (),
node: Slice(
ExprSlice {
lower: Some(
Attributed {
range: 126..127,
custom: (),
node: Constant(
ExprConstant {
@ -346,13 +341,13 @@ expression: parse_ast
3,
),
kind: None,
range: 126..127,
},
),
},
),
upper: Some(
Attributed {
range: 128..129,
custom: (),
node: Constant(
ExprConstant {
@ -360,21 +355,21 @@ expression: parse_ast
5,
),
kind: None,
range: 128..129,
},
),
},
),
step: None,
range: 126..129,
},
),
},
Attributed {
range: 131..149,
custom: (),
node: Starred(
ExprStarred {
value: Attributed {
range: 132..149,
custom: (),
node: Name(
ExprName {
@ -382,22 +377,27 @@ expression: parse_ast
"indexes_to_select",
),
ctx: Load,
range: 132..149,
},
),
},
ctx: Load,
range: 131..149,
},
),
},
],
ctx: Load,
range: 126..149,
},
),
},
ctx: Load,
range: 120..150,
},
),
},
range: 120..150,
},
),
},

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

@ -4,24 +4,20 @@ expression: parse_ast
---
[
Attributed {
range: 0..134,
custom: (),
node: Try(
StmtTry {
body: [
Attributed {
range: 9..28,
custom: (),
node: Raise(
StmtRaise {
exc: Some(
Attributed {
range: 15..28,
custom: (),
node: Call(
ExprCall {
func: Attributed {
range: 15..25,
custom: (),
node: Name(
ExprName {
@ -29,12 +25,12 @@ expression: parse_ast
"ValueError",
),
ctx: Load,
range: 15..25,
},
),
},
args: [
Attributed {
range: 26..27,
custom: (),
node: Constant(
ExprConstant {
@ -42,29 +38,30 @@ expression: parse_ast
1,
),
kind: None,
range: 26..27,
},
),
},
],
keywords: [],
range: 15..28,
},
),
},
),
cause: None,
range: 9..28,
},
),
},
],
handlers: [
Attributed {
range: 29..82,
custom: (),
node: ExceptHandler(
ExcepthandlerExceptHandler {
type_: Some(
Attributed {
range: 36..45,
custom: (),
node: Name(
ExprName {
@ -72,6 +69,7 @@ expression: parse_ast
"TypeError",
),
ctx: Load,
range: 36..45,
},
),
},
@ -83,17 +81,14 @@ expression: parse_ast
),
body: [
Attributed {
range: 56..82,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 56..82,
custom: (),
node: Call(
ExprCall {
func: Attributed {
range: 56..61,
custom: (),
node: Name(
ExprName {
@ -101,18 +96,17 @@ expression: parse_ast
"print",
),
ctx: Load,
range: 56..61,
},
),
},
args: [
Attributed {
range: 62..81,
custom: (),
node: JoinedStr(
ExprJoinedStr {
values: [
Attributed {
range: 62..81,
custom: (),
node: Constant(
ExprConstant {
@ -120,21 +114,19 @@ expression: parse_ast
"caught ",
),
kind: None,
range: 62..81,
},
),
},
Attributed {
range: 62..81,
custom: (),
node: FormattedValue(
ExprFormattedValue {
value: Attributed {
range: 72..79,
custom: (),
node: Call(
ExprCall {
func: Attributed {
range: 72..76,
custom: (),
node: Name(
ExprName {
@ -142,12 +134,12 @@ expression: parse_ast
"type",
),
ctx: Load,
range: 72..76,
},
),
},
args: [
Attributed {
range: 77..78,
custom: (),
node: Name(
ExprName {
@ -155,11 +147,13 @@ expression: parse_ast
"e",
),
ctx: Load,
range: 77..78,
},
),
},
],
keywords: [],
range: 72..79,
},
),
},
@ -167,33 +161,36 @@ expression: parse_ast
0,
),
format_spec: None,
range: 62..81,
},
),
},
],
range: 62..81,
},
),
},
],
keywords: [],
range: 56..82,
},
),
},
range: 56..82,
},
),
},
],
range: 29..82,
},
),
},
Attributed {
range: 83..134,
custom: (),
node: ExceptHandler(
ExcepthandlerExceptHandler {
type_: Some(
Attributed {
range: 90..97,
custom: (),
node: Name(
ExprName {
@ -201,6 +198,7 @@ expression: parse_ast
"OSError",
),
ctx: Load,
range: 90..97,
},
),
},
@ -212,17 +210,14 @@ expression: parse_ast
),
body: [
Attributed {
range: 108..134,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 108..134,
custom: (),
node: Call(
ExprCall {
func: Attributed {
range: 108..113,
custom: (),
node: Name(
ExprName {
@ -230,18 +225,17 @@ expression: parse_ast
"print",
),
ctx: Load,
range: 108..113,
},
),
},
args: [
Attributed {
range: 114..133,
custom: (),
node: JoinedStr(
ExprJoinedStr {
values: [
Attributed {
range: 114..133,
custom: (),
node: Constant(
ExprConstant {
@ -249,21 +243,19 @@ expression: parse_ast
"caught ",
),
kind: None,
range: 114..133,
},
),
},
Attributed {
range: 114..133,
custom: (),
node: FormattedValue(
ExprFormattedValue {
value: Attributed {
range: 124..131,
custom: (),
node: Call(
ExprCall {
func: Attributed {
range: 124..128,
custom: (),
node: Name(
ExprName {
@ -271,12 +263,12 @@ expression: parse_ast
"type",
),
ctx: Load,
range: 124..128,
},
),
},
args: [
Attributed {
range: 129..130,
custom: (),
node: Name(
ExprName {
@ -284,11 +276,13 @@ expression: parse_ast
"e",
),
ctx: Load,
range: 129..130,
},
),
},
],
keywords: [],
range: 124..131,
},
),
},
@ -296,28 +290,34 @@ expression: parse_ast
0,
),
format_spec: None,
range: 114..133,
},
),
},
],
range: 114..133,
},
),
},
],
keywords: [],
range: 108..134,
},
),
},
range: 108..134,
},
),
},
],
range: 83..134,
},
),
},
],
orelse: [],
finalbody: [],
range: 0..134,
},
),
},

96
parser/src/snapshots/rustpython_parser__parser__tests__try_star.snap generated
View file

@ -4,24 +4,20 @@ expression: parse_ast
---
[
Attributed {
range: 0..260,
custom: (),
node: TryStar(
StmtTryStar {
body: [
Attributed {
range: 9..98,
custom: (),
node: Raise(
StmtRaise {
exc: Some(
Attributed {
range: 15..98,
custom: (),
node: Call(
ExprCall {
func: Attributed {
range: 15..29,
custom: (),
node: Name(
ExprName {
@ -29,12 +25,12 @@ expression: parse_ast
"ExceptionGroup",
),
ctx: Load,
range: 15..29,
},
),
},
args: [
Attributed {
range: 30..34,
custom: (),
node: Constant(
ExprConstant {
@ -42,22 +38,20 @@ expression: parse_ast
"eg",
),
kind: None,
range: 30..34,
},
),
},
Attributed {
range: 44..97,
custom: (),
node: List(
ExprList {
elts: [
Attributed {
range: 45..58,
custom: (),
node: Call(
ExprCall {
func: Attributed {
range: 45..55,
custom: (),
node: Name(
ExprName {
@ -65,12 +59,12 @@ expression: parse_ast
"ValueError",
),
ctx: Load,
range: 45..55,
},
),
},
args: [
Attributed {
range: 56..57,
custom: (),
node: Constant(
ExprConstant {
@ -78,21 +72,21 @@ expression: parse_ast
1,
),
kind: None,
range: 56..57,
},
),
},
],
keywords: [],
range: 45..58,
},
),
},
Attributed {
range: 60..72,
custom: (),
node: Call(
ExprCall {
func: Attributed {
range: 60..69,
custom: (),
node: Name(
ExprName {
@ -100,12 +94,12 @@ expression: parse_ast
"TypeError",
),
ctx: Load,
range: 60..69,
},
),
},
args: [
Attributed {
range: 70..71,
custom: (),
node: Constant(
ExprConstant {
@ -113,21 +107,21 @@ expression: parse_ast
2,
),
kind: None,
range: 70..71,
},
),
},
],
keywords: [],
range: 60..72,
},
),
},
Attributed {
range: 74..84,
custom: (),
node: Call(
ExprCall {
func: Attributed {
range: 74..81,
custom: (),
node: Name(
ExprName {
@ -135,12 +129,12 @@ expression: parse_ast
"OSError",
),
ctx: Load,
range: 74..81,
},
),
},
args: [
Attributed {
range: 82..83,
custom: (),
node: Constant(
ExprConstant {
@ -148,21 +142,21 @@ expression: parse_ast
3,
),
kind: None,
range: 82..83,
},
),
},
],
keywords: [],
range: 74..84,
},
),
},
Attributed {
range: 86..96,
custom: (),
node: Call(
ExprCall {
func: Attributed {
range: 86..93,
custom: (),
node: Name(
ExprName {
@ -170,12 +164,12 @@ expression: parse_ast
"OSError",
),
ctx: Load,
range: 86..93,
},
),
},
args: [
Attributed {
range: 94..95,
custom: (),
node: Constant(
ExprConstant {
@ -183,39 +177,42 @@ expression: parse_ast
4,
),
kind: None,
range: 94..95,
},
),
},
],
keywords: [],
range: 86..96,
},
),
},
],
ctx: Load,
range: 44..97,
},
),
},
],
keywords: [],
range: 15..98,
},
),
},
),
cause: None,
range: 9..98,
},
),
},
],
handlers: [
Attributed {
range: 99..180,
custom: (),
node: ExceptHandler(
ExcepthandlerExceptHandler {
type_: Some(
Attributed {
range: 107..116,
custom: (),
node: Name(
ExprName {
@ -223,6 +220,7 @@ expression: parse_ast
"TypeError",
),
ctx: Load,
range: 107..116,
},
),
},
@ -234,17 +232,14 @@ expression: parse_ast
),
body: [
Attributed {
range: 127..180,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 127..180,
custom: (),
node: Call(
ExprCall {
func: Attributed {
range: 127..132,
custom: (),
node: Name(
ExprName {
@ -252,18 +247,17 @@ expression: parse_ast
"print",
),
ctx: Load,
range: 127..132,
},
),
},
args: [
Attributed {
range: 133..179,
custom: (),
node: JoinedStr(
ExprJoinedStr {
values: [
Attributed {
range: 133..179,
custom: (),
node: Constant(
ExprConstant {
@ -271,21 +265,19 @@ expression: parse_ast
"caught ",
),
kind: None,
range: 133..179,
},
),
},
Attributed {
range: 133..179,
custom: (),
node: FormattedValue(
ExprFormattedValue {
value: Attributed {
range: 143..150,
custom: (),
node: Call(
ExprCall {
func: Attributed {
range: 143..147,
custom: (),
node: Name(
ExprName {
@ -293,12 +285,12 @@ expression: parse_ast
"type",
),
ctx: Load,
range: 143..147,
},
),
},
args: [
Attributed {
range: 148..149,
custom: (),
node: Name(
ExprName {
@ -306,11 +298,13 @@ expression: parse_ast
"e",
),
ctx: Load,
range: 148..149,
},
),
},
],
keywords: [],
range: 143..150,
},
),
},
@ -318,11 +312,11 @@ expression: parse_ast
0,
),
format_spec: None,
range: 133..179,
},
),
},
Attributed {
range: 133..179,
custom: (),
node: Constant(
ExprConstant {
@ -330,21 +324,19 @@ expression: parse_ast
" with nested ",
),
kind: None,
range: 133..179,
},
),
},
Attributed {
range: 133..179,
custom: (),
node: FormattedValue(
ExprFormattedValue {
value: Attributed {
range: 165..177,
custom: (),
node: Attribute(
ExprAttribute {
value: Attributed {
range: 165..166,
custom: (),
node: Name(
ExprName {
@ -352,6 +344,7 @@ expression: parse_ast
"e",
),
ctx: Load,
range: 165..166,
},
),
},
@ -359,6 +352,7 @@ expression: parse_ast
"exceptions",
),
ctx: Load,
range: 165..177,
},
),
},
@ -366,33 +360,36 @@ expression: parse_ast
0,
),
format_spec: None,
range: 133..179,
},
),
},
],
range: 133..179,
},
),
},
],
keywords: [],
range: 127..180,
},
),
},
range: 127..180,
},
),
},
],
range: 99..180,
},
),
},
Attributed {
range: 181..260,
custom: (),
node: ExceptHandler(
ExcepthandlerExceptHandler {
type_: Some(
Attributed {
range: 189..196,
custom: (),
node: Name(
ExprName {
@ -400,6 +397,7 @@ expression: parse_ast
"OSError",
),
ctx: Load,
range: 189..196,
},
),
},
@ -411,17 +409,14 @@ expression: parse_ast
),
body: [
Attributed {
range: 207..260,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 207..260,
custom: (),
node: Call(
ExprCall {
func: Attributed {
range: 207..212,
custom: (),
node: Name(
ExprName {
@ -429,18 +424,17 @@ expression: parse_ast
"print",
),
ctx: Load,
range: 207..212,
},
),
},
args: [
Attributed {
range: 213..259,
custom: (),
node: JoinedStr(
ExprJoinedStr {
values: [
Attributed {
range: 213..259,
custom: (),
node: Constant(
ExprConstant {
@ -448,21 +442,19 @@ expression: parse_ast
"caught ",
),
kind: None,
range: 213..259,
},
),
},
Attributed {
range: 213..259,
custom: (),
node: FormattedValue(
ExprFormattedValue {
value: Attributed {
range: 223..230,
custom: (),
node: Call(
ExprCall {
func: Attributed {
range: 223..227,
custom: (),
node: Name(
ExprName {
@ -470,12 +462,12 @@ expression: parse_ast
"type",
),
ctx: Load,
range: 223..227,
},
),
},
args: [
Attributed {
range: 228..229,
custom: (),
node: Name(
ExprName {
@ -483,11 +475,13 @@ expression: parse_ast
"e",
),
ctx: Load,
range: 228..229,
},
),
},
],
keywords: [],
range: 223..230,
},
),
},
@ -495,11 +489,11 @@ expression: parse_ast
0,
),
format_spec: None,
range: 213..259,
},
),
},
Attributed {
range: 213..259,
custom: (),
node: Constant(
ExprConstant {
@ -507,21 +501,19 @@ expression: parse_ast
" with nested ",
),
kind: None,
range: 213..259,
},
),
},
Attributed {
range: 213..259,
custom: (),
node: FormattedValue(
ExprFormattedValue {
value: Attributed {
range: 245..257,
custom: (),
node: Attribute(
ExprAttribute {
value: Attributed {
range: 245..246,
custom: (),
node: Name(
ExprName {
@ -529,6 +521,7 @@ expression: parse_ast
"e",
),
ctx: Load,
range: 245..246,
},
),
},
@ -536,6 +529,7 @@ expression: parse_ast
"exceptions",
),
ctx: Load,
range: 245..257,
},
),
},
@ -543,28 +537,34 @@ expression: parse_ast
0,
),
format_spec: None,
range: 213..259,
},
),
},
],
range: 213..259,
},
),
},
],
keywords: [],
range: 207..260,
},
),
},
range: 207..260,
},
),
},
],
range: 181..260,
},
),
},
],
orelse: [],
finalbody: [],
range: 0..260,
},
),
},

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

@ -4,7 +4,6 @@ expression: parse_ast
---
[
Attributed {
range: 1..49,
custom: (),
node: FunctionDef(
StmtFunctionDef {
@ -16,7 +15,6 @@ expression: parse_ast
args: [],
vararg: Some(
Attributed {
range: 20..29,
custom: (),
node: ArgData {
arg: Identifier(
@ -24,12 +22,10 @@ expression: parse_ast
),
annotation: Some(
Attributed {
range: 26..29,
custom: (),
node: Starred(
ExprStarred {
value: Attributed {
range: 27..29,
custom: (),
node: Name(
ExprName {
@ -37,15 +33,18 @@ expression: parse_ast
"Ts",
),
ctx: Load,
range: 27..29,
},
),
},
ctx: Load,
range: 26..29,
},
),
},
),
type_comment: None,
range: 20..29,
},
},
),
@ -53,23 +52,24 @@ expression: parse_ast
kw_defaults: [],
kwarg: None,
defaults: [],
range: 19..29,
},
body: [
Attributed {
range: 46..49,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 46..49,
custom: (),
node: Constant(
ExprConstant {
value: Ellipsis,
kind: None,
range: 46..49,
},
),
},
range: 46..49,
},
),
},
@ -77,12 +77,10 @@ expression: parse_ast
decorator_list: [],
returns: Some(
Attributed {
range: 34..44,
custom: (),
node: Subscript(
ExprSubscript {
value: Attributed {
range: 34..39,
custom: (),
node: Name(
ExprName {
@ -90,16 +88,15 @@ expression: parse_ast
"Tuple",
),
ctx: Load,
range: 34..39,
},
),
},
slice: Attributed {
range: 40..43,
custom: (),
node: Starred(
ExprStarred {
value: Attributed {
range: 41..43,
custom: (),
node: Name(
ExprName {
@ -107,19 +104,23 @@ expression: parse_ast
"Ts",
),
ctx: Load,
range: 41..43,
},
),
},
ctx: Load,
range: 40..43,
},
),
},
ctx: Load,
range: 34..44,
},
),
},
),
type_comment: None,
range: 1..49,
},
),
},

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

File diff suppressed because it is too large Load diff

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

@ -4,12 +4,10 @@ expression: parse_ast
---
[
Attributed {
range: 0..15,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..15,
custom: (),
node: Constant(
ExprConstant {
@ -17,9 +15,11 @@ expression: parse_ast
"\u{8}",
),
kind: None,
range: 0..15,
},
),
},
range: 0..15,
},
),
},

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

@ -4,12 +4,10 @@ expression: parse_ast
---
[
Attributed {
range: 0..9,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..9,
custom: (),
node: Constant(
ExprConstant {
@ -17,9 +15,11 @@ expression: parse_ast
"\u{7}",
),
kind: None,
range: 0..9,
},
),
},
range: 0..9,
},
),
},

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

@ -4,12 +4,10 @@ expression: parse_ast
---
[
Attributed {
range: 0..21,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..21,
custom: (),
node: Constant(
ExprConstant {
@ -17,9 +15,11 @@ expression: parse_ast
"\r",
),
kind: None,
range: 0..21,
},
),
},
range: 0..21,
},
),
},

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

@ -4,12 +4,10 @@ expression: parse_ast
---
[
Attributed {
range: 0..45,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..45,
custom: (),
node: Constant(
ExprConstant {
@ -17,9 +15,11 @@ expression: parse_ast
"\u{89}",
),
kind: None,
range: 0..45,
},
),
},
range: 0..45,
},
),
},

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

@ -4,12 +4,10 @@ expression: parse_ast
---
[
Attributed {
range: 0..12,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..12,
custom: (),
node: Constant(
ExprConstant {
@ -17,9 +15,11 @@ expression: parse_ast
"\u{7f}",
),
kind: None,
range: 0..12,
},
),
},
range: 0..12,
},
),
},

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

@ -4,12 +4,10 @@ expression: parse_ast
---
[
Attributed {
range: 0..738,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..738,
custom: (),
node: Constant(
ExprConstant {
@ -274,9 +272,11 @@ expression: parse_ast
],
),
kind: None,
range: 0..738,
},
),
},
range: 0..738,
},
),
},

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

@ -4,12 +4,10 @@ expression: parse_ast
---
[
Attributed {
range: 0..12,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..12,
custom: (),
node: Constant(
ExprConstant {
@ -17,9 +15,11 @@ expression: parse_ast
"\u{1b}",
),
kind: None,
range: 0..12,
},
),
},
range: 0..12,
},
),
},

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

@ -4,12 +4,10 @@ expression: parse_ast
---
[
Attributed {
range: 0..13,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..13,
custom: (),
node: Constant(
ExprConstant {
@ -28,9 +26,11 @@ expression: parse_ast
],
),
kind: None,
range: 0..13,
},
),
},
range: 0..13,
},
),
},

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

@ -4,12 +4,10 @@ expression: parse_ast
---
[
Attributed {
range: 0..14,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..14,
custom: (),
node: Constant(
ExprConstant {
@ -23,9 +21,11 @@ expression: parse_ast
],
),
kind: None,
range: 0..14,
},
),
},
range: 0..14,
},
),
},

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

@ -4,12 +4,10 @@ expression: parse_ast
---
[
Attributed {
range: 0..15,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..15,
custom: (),
node: Constant(
ExprConstant {
@ -17,9 +15,11 @@ expression: parse_ast
"\u{c}",
),
kind: None,
range: 0..15,
},
),
},
range: 0..15,
},
),
},

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

@ -4,18 +4,15 @@ expression: parse_ast
---
[
Attributed {
range: 0..8,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..8,
custom: (),
node: JoinedStr(
ExprJoinedStr {
values: [
Attributed {
range: 0..8,
custom: (),
node: Constant(
ExprConstant {
@ -23,16 +20,15 @@ expression: parse_ast
"\\",
),
kind: None,
range: 0..8,
},
),
},
Attributed {
range: 0..8,
custom: (),
node: FormattedValue(
ExprFormattedValue {
value: Attributed {
range: 5..6,
custom: (),
node: Name(
ExprName {
@ -40,6 +36,7 @@ expression: parse_ast
"x",
),
ctx: Load,
range: 5..6,
},
),
},
@ -47,13 +44,16 @@ expression: parse_ast
0,
),
format_spec: None,
range: 0..8,
},
),
},
],
range: 0..8,
},
),
},
range: 0..8,
},
),
},

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

@ -4,18 +4,15 @@ expression: parse_ast
---
[
Attributed {
range: 0..8,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..8,
custom: (),
node: JoinedStr(
ExprJoinedStr {
values: [
Attributed {
range: 0..8,
custom: (),
node: Constant(
ExprConstant {
@ -23,16 +20,15 @@ expression: parse_ast
"\n",
),
kind: None,
range: 0..8,
},
),
},
Attributed {
range: 0..8,
custom: (),
node: FormattedValue(
ExprFormattedValue {
value: Attributed {
range: 5..6,
custom: (),
node: Name(
ExprName {
@ -40,6 +36,7 @@ expression: parse_ast
"x",
),
ctx: Load,
range: 5..6,
},
),
},
@ -47,13 +44,16 @@ expression: parse_ast
0,
),
format_spec: None,
range: 0..8,
},
),
},
],
range: 0..8,
},
),
},
range: 0..8,
},
),
},

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

@ -4,18 +4,15 @@ expression: parse_ast
---
[
Attributed {
range: 0..9,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..9,
custom: (),
node: JoinedStr(
ExprJoinedStr {
values: [
Attributed {
range: 0..9,
custom: (),
node: Constant(
ExprConstant {
@ -23,16 +20,15 @@ expression: parse_ast
"\\\n",
),
kind: None,
range: 0..9,
},
),
},
Attributed {
range: 0..9,
custom: (),
node: FormattedValue(
ExprFormattedValue {
value: Attributed {
range: 6..7,
custom: (),
node: Name(
ExprName {
@ -40,6 +36,7 @@ expression: parse_ast
"x",
),
ctx: Load,
range: 6..7,
},
),
},
@ -47,13 +44,16 @@ expression: parse_ast
0,
),
format_spec: None,
range: 0..9,
},
),
},
],
range: 0..9,
},
),
},
range: 0..9,
},
),
},

8
parser/src/snapshots/rustpython_parser__string__tests__fstring_parse_self_documenting_base.snap generated
View file

@ -4,7 +4,6 @@ expression: parse_ast
---
[
Attributed {
range: 0..10,
custom: (),
node: Constant(
ExprConstant {
@ -12,11 +11,11 @@ expression: parse_ast
"user=",
),
kind: None,
range: 0..10,
},
),
},
Attributed {
range: 0..10,
custom: (),
node: Constant(
ExprConstant {
@ -24,16 +23,15 @@ expression: parse_ast
"",
),
kind: None,
range: 0..10,
},
),
},
Attributed {
range: 0..10,
custom: (),
node: FormattedValue(
ExprFormattedValue {
value: Attributed {
range: 3..7,
custom: (),
node: Name(
ExprName {
@ -41,6 +39,7 @@ expression: parse_ast
"user",
),
ctx: Load,
range: 3..7,
},
),
},
@ -48,6 +47,7 @@ expression: parse_ast
114,
),
format_spec: None,
range: 0..10,
},
),
},

20
parser/src/snapshots/rustpython_parser__string__tests__fstring_parse_self_documenting_base_more.snap generated
View file

@ -4,7 +4,6 @@ expression: parse_ast
---
[
Attributed {
range: 0..38,
custom: (),
node: Constant(
ExprConstant {
@ -12,11 +11,11 @@ expression: parse_ast
"mix ",
),
kind: None,
range: 0..38,
},
),
},
Attributed {
range: 0..38,
custom: (),
node: Constant(
ExprConstant {
@ -24,11 +23,11 @@ expression: parse_ast
"user=",
),
kind: None,
range: 0..38,
},
),
},
Attributed {
range: 0..38,
custom: (),
node: Constant(
ExprConstant {
@ -36,16 +35,15 @@ expression: parse_ast
"",
),
kind: None,
range: 0..38,
},
),
},
Attributed {
range: 0..38,
custom: (),
node: FormattedValue(
ExprFormattedValue {
value: Attributed {
range: 7..11,
custom: (),
node: Name(
ExprName {
@ -53,6 +51,7 @@ expression: parse_ast
"user",
),
ctx: Load,
range: 7..11,
},
),
},
@ -60,11 +59,11 @@ expression: parse_ast
114,
),
format_spec: None,
range: 0..38,
},
),
},
Attributed {
range: 0..38,
custom: (),
node: Constant(
ExprConstant {
@ -72,11 +71,11 @@ expression: parse_ast
" with text and ",
),
kind: None,
range: 0..38,
},
),
},
Attributed {
range: 0..38,
custom: (),
node: Constant(
ExprConstant {
@ -84,11 +83,11 @@ expression: parse_ast
"second=",
),
kind: None,
range: 0..38,
},
),
},
Attributed {
range: 0..38,
custom: (),
node: Constant(
ExprConstant {
@ -96,16 +95,15 @@ expression: parse_ast
"",
),
kind: None,
range: 0..38,
},
),
},
Attributed {
range: 0..38,
custom: (),
node: FormattedValue(
ExprFormattedValue {
value: Attributed {
range: 29..35,
custom: (),
node: Name(
ExprName {
@ -113,6 +111,7 @@ expression: parse_ast
"second",
),
ctx: Load,
range: 29..35,
},
),
},
@ -120,6 +119,7 @@ expression: parse_ast
114,
),
format_spec: None,
range: 0..38,
},
),
},

12
parser/src/snapshots/rustpython_parser__string__tests__fstring_parse_self_documenting_format.snap generated
View file

@ -4,7 +4,6 @@ expression: parse_ast
---
[
Attributed {
range: 0..14,
custom: (),
node: Constant(
ExprConstant {
@ -12,11 +11,11 @@ expression: parse_ast
"user=",
),
kind: None,
range: 0..14,
},
),
},
Attributed {
range: 0..14,
custom: (),
node: Constant(
ExprConstant {
@ -24,16 +23,15 @@ expression: parse_ast
"",
),
kind: None,
range: 0..14,
},
),
},
Attributed {
range: 0..14,
custom: (),
node: FormattedValue(
ExprFormattedValue {
value: Attributed {
range: 3..7,
custom: (),
node: Name(
ExprName {
@ -41,6 +39,7 @@ expression: parse_ast
"user",
),
ctx: Load,
range: 3..7,
},
),
},
@ -49,13 +48,11 @@ expression: parse_ast
),
format_spec: Some(
Attributed {
range: 0..14,
custom: (),
node: JoinedStr(
ExprJoinedStr {
values: [
Attributed {
range: 0..14,
custom: (),
node: Constant(
ExprConstant {
@ -63,14 +60,17 @@ expression: parse_ast
">10",
),
kind: None,
range: 0..14,
},
),
},
],
range: 0..14,
},
),
},
),
range: 0..14,
},
),
},

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

@ -4,18 +4,15 @@ expression: parse_ast
---
[
Attributed {
range: 0..11,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..11,
custom: (),
node: JoinedStr(
ExprJoinedStr {
values: [
Attributed {
range: 0..11,
custom: (),
node: Constant(
ExprConstant {
@ -23,16 +20,15 @@ expression: parse_ast
"\n",
),
kind: None,
range: 0..11,
},
),
},
Attributed {
range: 0..11,
custom: (),
node: FormattedValue(
ExprFormattedValue {
value: Attributed {
range: 6..7,
custom: (),
node: Name(
ExprName {
@ -40,6 +36,7 @@ expression: parse_ast
"x",
),
ctx: Load,
range: 6..7,
},
),
},
@ -47,13 +44,16 @@ expression: parse_ast
0,
),
format_spec: None,
range: 0..11,
},
),
},
],
range: 0..11,
},
),
},
range: 0..11,
},
),
},

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

@ -4,12 +4,10 @@ expression: parse_ast
---
[
Attributed {
range: 0..9,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..9,
custom: (),
node: Constant(
ExprConstant {
@ -17,9 +15,11 @@ expression: parse_ast
"\u{88}",
),
kind: None,
range: 0..9,
},
),
},
range: 0..9,
},
),
},

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

@ -4,18 +4,15 @@ expression: parse_ast
---
[
Attributed {
range: 0..17,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..17,
custom: (),
node: JoinedStr(
ExprJoinedStr {
values: [
Attributed {
range: 0..17,
custom: (),
node: Constant(
ExprConstant {
@ -23,13 +20,16 @@ expression: parse_ast
"Hello world",
),
kind: None,
range: 0..17,
},
),
},
],
range: 0..17,
},
),
},
range: 0..17,
},
),
},

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

@ -4,18 +4,15 @@ expression: parse_ast
---
[
Attributed {
range: 0..17,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..17,
custom: (),
node: JoinedStr(
ExprJoinedStr {
values: [
Attributed {
range: 0..17,
custom: (),
node: Constant(
ExprConstant {
@ -23,13 +20,16 @@ expression: parse_ast
"Hello world",
),
kind: None,
range: 0..17,
},
),
},
],
range: 0..17,
},
),
},
range: 0..17,
},
),
},

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

@ -4,18 +4,15 @@ expression: parse_ast
---
[
Attributed {
range: 0..22,
custom: (),
node: Expr(
StmtExpr {
value: Attributed {
range: 0..22,
custom: (),
node: JoinedStr(
ExprJoinedStr {
values: [
Attributed {
range: 0..22,
custom: (),
node: Constant(
ExprConstant {
@ -23,16 +20,15 @@ expression: parse_ast
"Hello world",
),
kind: None,
range: 0..22,
},
),
},
Attributed {
range: 9..22,
custom: (),
node: FormattedValue(
ExprFormattedValue {
value: Attributed {
range: 17..20,
custom: (),
node: Constant(
ExprConstant {
@ -40,6 +36,7 @@ expression: parse_ast
"!",
),
kind: None,
range: 17..20,
},
),
},
@ -47,13 +44,16 @@ expression: parse_ast
0,
),
format_spec: None,
range: 9..22,
},
),
},
],
range: 0..22,
},
),
},
range: 0..22,
},
),
},

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

@ -4,12 +4,10 @@ expression: parse_ast
---
[
Attributed {
range: 0..18,
custom: (),
node: FormattedValue(
ExprFormattedValue {
value: Attributed {
range: 3..4,
custom: (),
node: Name(
ExprName {
@ -17,6 +15,7 @@ expression: parse_ast
"a",
),
ctx: Load,
range: 3..4,
},
),
},
@ -24,16 +23,15 @@ expression: parse_ast
0,
),
format_spec: None,
range: 0..18,
},
),
},
Attributed {
range: 0..18,
custom: (),
node: FormattedValue(
ExprFormattedValue {
value: Attributed {
range: 7..8,
custom: (),
node: Name(
ExprName {
@ -41,6 +39,7 @@ expression: parse_ast
"b",
),
ctx: Load,
range: 7..8,
},
),
},
@ -48,11 +47,11 @@ expression: parse_ast
0,
),
format_spec: None,
range: 0..18,
},
),
},
Attributed {
range: 0..18,
custom: (),
node: Constant(
ExprConstant {
@ -60,6 +59,7 @@ expression: parse_ast
"{foo}",
),
kind: None,
range: 0..18,
},
),
},

8
parser/src/snapshots/rustpython_parser__string__tests__parse_fstring_equals.snap generated
View file

@ -4,17 +4,14 @@ expression: parse_ast
---
[
Attributed {
range: 0..13,
custom: (),
node: FormattedValue(
ExprFormattedValue {
value: Attributed {
range: 3..11,
custom: (),
node: Compare(
ExprCompare {
left: Attributed {
range: 3..5,
custom: (),
node: Constant(
ExprConstant {
@ -22,6 +19,7 @@ expression: parse_ast
42,
),
kind: None,
range: 3..5,
},
),
},
@ -30,7 +28,6 @@ expression: parse_ast
],
comparators: [
Attributed {
range: 9..11,
custom: (),
node: Constant(
ExprConstant {
@ -38,10 +35,12 @@ expression: parse_ast
42,
),
kind: None,
range: 9..11,
},
),
},
],
range: 3..11,
},
),
},
@ -49,6 +48,7 @@ expression: parse_ast
0,
),
format_spec: None,
range: 0..13,
},
),
},

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

@ -4,12 +4,10 @@ expression: parse_ast
---
[
Attributed {
range: 0..15,
custom: (),
node: FormattedValue(
ExprFormattedValue {
value: Attributed {
range: 3..6,
custom: (),
node: Name(
ExprName {
@ -17,6 +15,7 @@ expression: parse_ast
"foo",
),
ctx: Load,
range: 3..6,
},
),
},
@ -25,18 +24,15 @@ expression: parse_ast
),
format_spec: Some(
Attributed {
range: 0..15,
custom: (),
node: JoinedStr(
ExprJoinedStr {
values: [
Attributed {
range: 0..15,
custom: (),
node: FormattedValue(
ExprFormattedValue {
value: Attributed {
range: 8..12,
custom: (),
node: Name(
ExprName {
@ -44,6 +40,7 @@ expression: parse_ast
"spec",
),
ctx: Load,
range: 8..12,
},
),
},
@ -51,14 +48,17 @@ expression: parse_ast
0,
),
format_spec: None,
range: 0..15,
},
),
},
],
range: 0..15,
},
),
},
),
range: 0..15,
},
),
},

Some files were not shown because too many files have changed in this diff Show more