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

Generate all located variants, generate enum implementations

Browse source
This commit is contained in:
Micha Reiser 2023-05-13 17:43:07 +02:00
parent 7e48ec46b9
commit bbfaf17b0b
No known key found for this signature in database
6 changed files with 480 additions and 134 deletions
Download patch file Download diff file Expand all files Collapse all files

1
ast/Cargo.toml
View file

@ -22,3 +22,4 @@ rustpython-literal = { workspace = true, optional = true }
is-macro = { workspace = true }
num-bigint = { workspace = true }
static_assertions = "1.1.0"

98
ast/asdl_rs.py
View file

@ -1,6 +1,6 @@
# spell-checker:words dfn dfns
#! /usr/bin/env python
# ! /usr/bin/env python
"""Generate Rust code from an ASDL description."""
import sys
@ -362,17 +362,17 @@ class StructVisitor(EmitVisitor):
typ = f"{typ}<R>"
# don't box if we're doing Vec<T>, but do box if we're doing Vec<Option<Box<T>>>
if (
field_type
and field_type.boxed
and (not (parent.product or field.seq) or field.opt)
field_type
and field_type.boxed
and (not (parent.product or field.seq) or field.opt)
):
typ = f"Box<{typ}>"
if field.opt or (
# When a dictionary literal contains dictionary unpacking (e.g., `{**d}`),
# the expression to be unpacked goes in `values` with a `None` at the corresponding
# position in `keys`. To handle this, the type of `keys` needs to be `Option<Vec<T>>`.
constructor == "Dict"
and field.name == "keys"
# When a dictionary literal contains dictionary unpacking (e.g., `{**d}`),
# the expression to be unpacked goes in `values` with a `None` at the corresponding
# position in `keys`. To handle this, the type of `keys` needs to be `Option<Vec<T>>`.
constructor == "Dict"
and field.name == "keys"
):
typ = f"Option<{typ}>"
if field.seq:
@ -939,16 +939,32 @@ class RangedDefVisitor(EmitVisitor):
if info.is_simple:
return
sum_match_arms = ""
for ty in sum.types:
info = self.type_info[ty.name]
self.make_ranged_impl(info)
variant_info = self.type_info[ty.name]
sum_match_arms += f" Self::{variant_info.rust_name}(node) => node.range(),"
self.emit_ranged_impl(variant_info)
if not info.no_cfg(self.type_info):
self.emit('#[cfg(feature = "more-attributes")]', 0)
self.emit(f"""
impl Ranged for crate::{info.rust_sum_name} {{
fn range(&self) -> TextRange {{
match self {{
{sum_match_arms}
}}
}}
}}
""".lstrip(), 0)
def visitProduct(self, product, name, depth):
info = self.type_info[name]
self.make_ranged_impl(info)
self.emit_ranged_impl(info)
def make_ranged_impl(self, info):
def emit_ranged_impl(self, info):
if not info.no_cfg(self.type_info):
self.emit('#[cfg(feature = "more-attributes")]', 0)
@ -962,6 +978,7 @@ class RangedDefVisitor(EmitVisitor):
""".strip()
)
class LocatedDefVisitor(EmitVisitor):
def visitModule(self, mod):
for dfn in mod.dfns:
@ -973,36 +990,58 @@ class LocatedDefVisitor(EmitVisitor):
def visitSum(self, sum, name, depth):
info = self.type_info[name]
self.emit_type_alias(info)
if info.is_simple:
return
sum_match_arms = ""
for ty in sum.types:
info = self.type_info[ty.name]
self.make_located_impl(info)
variant_info = self.type_info[ty.name]
sum_match_arms += f" Self::{variant_info.rust_name}(node) => node.range(),"
self.emit_type_alias(variant_info)
self.emit_located_impl(variant_info)
if not info.no_cfg(self.type_info):
self.emit('#[cfg(feature = "more-attributes")]', 0)
self.emit(f"""
impl Located for {info.rust_sum_name} {{
fn range(&self) -> SourceRange {{
match self {{
{sum_match_arms}
}}
}}
}}
""".lstrip(), 0)
def visitProduct(self, product, name, depth):
info = self.type_info[name]
self.make_located_impl(info)
self.emit_type_alias(info)
self.emit_located_impl(info)
def make_located_impl(self, info):
def emit_type_alias(self, info):
generics = "" if info.is_simple else "::<SourceRange>"
self.emit(f"pub type {info.rust_sum_name} = crate::generic::{info.rust_sum_name}{generics};", 0)
self.emit("", 0)
def emit_located_impl(self, info):
if not info.no_cfg(self.type_info):
self.emit('#[cfg(feature = "more-attributes")]', 0)
self.emit(f"pub type {info.rust_sum_name} = crate::generic::{info.rust_sum_name}::<SourceRange>;", 0)
if not info.no_cfg(self.type_info):
self.emit('#[cfg(feature = "more-attributes")]', 0)
self.file.write(
self.emit(
f"""
impl Located for {info.rust_sum_name} {{
fn range(&self) -> SourceRange {{
self.range
}}
}}
""".strip()
)
"""
, 0)
class ChainOfVisitors:
def __init__(self, *visitors):
@ -1035,6 +1074,7 @@ def write_ranged_def(mod, type_info, f):
def write_located_def(mod, type_info, f):
LocatedDefVisitor(f, type_info).visit(mod)
def write_ast_mod(mod, type_info, f):
f.write(
textwrap.dedent(
@ -1056,10 +1096,10 @@ def write_ast_mod(mod, type_info, f):
def main(
input_filename,
ast_dir,
module_filename,
dump_module=False,
input_filename,
ast_dir,
module_filename,
dump_module=False,
):
auto_gen_msg = AUTO_GEN_MESSAGE.format("/".join(Path(__file__).parts[-2:]))
mod = asdl.parse(input_filename)

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

@ -1,470 +1,753 @@
// File automatically generated by ast/asdl_rs.py.
#[cfg(feature = "more-attributes")]
pub type Mod = crate::generic::Mod<SourceRange>;
pub type ModModule = crate::generic::ModModule<SourceRange>;
#[cfg(feature = "more-attributes")]
impl Located for ModModule {
fn range(&self) -> SourceRange {
self.range
}
}
#[cfg(feature = "more-attributes")]
pub type ModInteractive = crate::generic::ModInteractive<SourceRange>;
#[cfg(feature = "more-attributes")]
impl Located for ModInteractive {
fn range(&self) -> SourceRange {
self.range
}
}
#[cfg(feature = "more-attributes")]
pub type ModExpression = crate::generic::ModExpression<SourceRange>;
#[cfg(feature = "more-attributes")]
impl Located for ModExpression {
fn range(&self) -> SourceRange {
self.range
}
}
#[cfg(feature = "more-attributes")]
pub type ModFunctionType = crate::generic::ModFunctionType<SourceRange>;
#[cfg(feature = "more-attributes")]
impl Located for ModFunctionType {
fn range(&self) -> SourceRange {
self.range
}
}
#[cfg(feature = "more-attributes")]
impl Located for Mod {
fn range(&self) -> SourceRange {
match self {
Self::Module(node) => node.range(),
Self::Interactive(node) => node.range(),
Self::Expression(node) => node.range(),
Self::FunctionType(node) => node.range(),
}
}
}
pub type Stmt = crate::generic::Stmt<SourceRange>;
pub type StmtFunctionDef = crate::generic::StmtFunctionDef<SourceRange>;
impl Located for StmtFunctionDef {
fn range(&self) -> SourceRange {
self.range
}
}
pub type StmtAsyncFunctionDef = crate::generic::StmtAsyncFunctionDef<SourceRange>;
impl Located for StmtAsyncFunctionDef {
fn range(&self) -> SourceRange {
self.range
}
}
pub type StmtClassDef = crate::generic::StmtClassDef<SourceRange>;
impl Located for StmtClassDef {
fn range(&self) -> SourceRange {
self.range
}
}
pub type StmtReturn = crate::generic::StmtReturn<SourceRange>;
impl Located for StmtReturn {
fn range(&self) -> SourceRange {
self.range
}
}
pub type StmtDelete = crate::generic::StmtDelete<SourceRange>;
impl Located for StmtDelete {
fn range(&self) -> SourceRange {
self.range
}
}
pub type StmtAssign = crate::generic::StmtAssign<SourceRange>;
impl Located for StmtAssign {
fn range(&self) -> SourceRange {
self.range
}
}
pub type StmtAugAssign = crate::generic::StmtAugAssign<SourceRange>;
impl Located for StmtAugAssign {
fn range(&self) -> SourceRange {
self.range
}
}
pub type StmtAnnAssign = crate::generic::StmtAnnAssign<SourceRange>;
impl Located for StmtAnnAssign {
fn range(&self) -> SourceRange {
self.range
}
}
pub type StmtFor = crate::generic::StmtFor<SourceRange>;
impl Located for StmtFor {
fn range(&self) -> SourceRange {
self.range
}
}
pub type StmtAsyncFor = crate::generic::StmtAsyncFor<SourceRange>;
impl Located for StmtAsyncFor {
fn range(&self) -> SourceRange {
self.range
}
}
pub type StmtWhile = crate::generic::StmtWhile<SourceRange>;
impl Located for StmtWhile {
fn range(&self) -> SourceRange {
self.range
}
}
pub type StmtIf = crate::generic::StmtIf<SourceRange>;
impl Located for StmtIf {
fn range(&self) -> SourceRange {
self.range
}
}
pub type StmtWith = crate::generic::StmtWith<SourceRange>;
impl Located for StmtWith {
fn range(&self) -> SourceRange {
self.range
}
}
pub type StmtAsyncWith = crate::generic::StmtAsyncWith<SourceRange>;
impl Located for StmtAsyncWith {
fn range(&self) -> SourceRange {
self.range
}
}
pub type StmtMatch = crate::generic::StmtMatch<SourceRange>;
impl Located for StmtMatch {
fn range(&self) -> SourceRange {
self.range
}
}
pub type StmtRaise = crate::generic::StmtRaise<SourceRange>;
impl Located for StmtRaise {
fn range(&self) -> SourceRange {
self.range
}
}
pub type StmtTry = crate::generic::StmtTry<SourceRange>;
impl Located for StmtTry {
fn range(&self) -> SourceRange {
self.range
}
}
pub type StmtTryStar = crate::generic::StmtTryStar<SourceRange>;
impl Located for StmtTryStar {
fn range(&self) -> SourceRange {
self.range
}
}
pub type StmtAssert = crate::generic::StmtAssert<SourceRange>;
impl Located for StmtAssert {
fn range(&self) -> SourceRange {
self.range
}
}
pub type StmtImport = crate::generic::StmtImport<SourceRange>;
impl Located for StmtImport {
fn range(&self) -> SourceRange {
self.range
}
}
pub type StmtImportFrom = crate::generic::StmtImportFrom<SourceRange>;
impl Located for StmtImportFrom {
fn range(&self) -> SourceRange {
self.range
}
}
pub type StmtGlobal = crate::generic::StmtGlobal<SourceRange>;
impl Located for StmtGlobal {
fn range(&self) -> SourceRange {
self.range
}
}
pub type StmtNonlocal = crate::generic::StmtNonlocal<SourceRange>;
impl Located for StmtNonlocal {
fn range(&self) -> SourceRange {
self.range
}
}
pub type StmtExpr = crate::generic::StmtExpr<SourceRange>;
impl Located for StmtExpr {
fn range(&self) -> SourceRange {
self.range
}
}
pub type StmtPass = crate::generic::StmtPass<SourceRange>;
impl Located for StmtPass {
fn range(&self) -> SourceRange {
self.range
}
}
pub type StmtBreak = crate::generic::StmtBreak<SourceRange>;
impl Located for StmtBreak {
fn range(&self) -> SourceRange {
self.range
}
}
pub type StmtContinue = crate::generic::StmtContinue<SourceRange>;
impl Located for StmtContinue {
fn range(&self) -> SourceRange {
self.range
}
}
impl Located for Stmt {
fn range(&self) -> SourceRange {
match self {
Self::FunctionDef(node) => node.range(),
Self::AsyncFunctionDef(node) => node.range(),
Self::ClassDef(node) => node.range(),
Self::Return(node) => node.range(),
Self::Delete(node) => node.range(),
Self::Assign(node) => node.range(),
Self::AugAssign(node) => node.range(),
Self::AnnAssign(node) => node.range(),
Self::For(node) => node.range(),
Self::AsyncFor(node) => node.range(),
Self::While(node) => node.range(),
Self::If(node) => node.range(),
Self::With(node) => node.range(),
Self::AsyncWith(node) => node.range(),
Self::Match(node) => node.range(),
Self::Raise(node) => node.range(),
Self::Try(node) => node.range(),
Self::TryStar(node) => node.range(),
Self::Assert(node) => node.range(),
Self::Import(node) => node.range(),
Self::ImportFrom(node) => node.range(),
Self::Global(node) => node.range(),
Self::Nonlocal(node) => node.range(),
Self::Expr(node) => node.range(),
Self::Pass(node) => node.range(),
Self::Break(node) => node.range(),
Self::Continue(node) => node.range(),
}
}
}
pub type Expr = crate::generic::Expr<SourceRange>;
pub type ExprBoolOp = crate::generic::ExprBoolOp<SourceRange>;
impl Located for ExprBoolOp {
fn range(&self) -> SourceRange {
self.range
}
}
pub type ExprNamedExpr = crate::generic::ExprNamedExpr<SourceRange>;
impl Located for ExprNamedExpr {
fn range(&self) -> SourceRange {
self.range
}
}
pub type ExprBinOp = crate::generic::ExprBinOp<SourceRange>;
impl Located for ExprBinOp {
fn range(&self) -> SourceRange {
self.range
}
}
pub type ExprUnaryOp = crate::generic::ExprUnaryOp<SourceRange>;
impl Located for ExprUnaryOp {
fn range(&self) -> SourceRange {
self.range
}
}
pub type ExprLambda = crate::generic::ExprLambda<SourceRange>;
impl Located for ExprLambda {
fn range(&self) -> SourceRange {
self.range
}
}
pub type ExprIfExp = crate::generic::ExprIfExp<SourceRange>;
impl Located for ExprIfExp {
fn range(&self) -> SourceRange {
self.range
}
}
pub type ExprDict = crate::generic::ExprDict<SourceRange>;
impl Located for ExprDict {
fn range(&self) -> SourceRange {
self.range
}
}
pub type ExprSet = crate::generic::ExprSet<SourceRange>;
impl Located for ExprSet {
fn range(&self) -> SourceRange {
self.range
}
}
pub type ExprListComp = crate::generic::ExprListComp<SourceRange>;
impl Located for ExprListComp {
fn range(&self) -> SourceRange {
self.range
}
}
pub type ExprSetComp = crate::generic::ExprSetComp<SourceRange>;
impl Located for ExprSetComp {
fn range(&self) -> SourceRange {
self.range
}
}
pub type ExprDictComp = crate::generic::ExprDictComp<SourceRange>;
impl Located for ExprDictComp {
fn range(&self) -> SourceRange {
self.range
}
}
pub type ExprGeneratorExp = crate::generic::ExprGeneratorExp<SourceRange>;
impl Located for ExprGeneratorExp {
fn range(&self) -> SourceRange {
self.range
}
}
pub type ExprAwait = crate::generic::ExprAwait<SourceRange>;
impl Located for ExprAwait {
fn range(&self) -> SourceRange {
self.range
}
}
pub type ExprYield = crate::generic::ExprYield<SourceRange>;
impl Located for ExprYield {
fn range(&self) -> SourceRange {
self.range
}
}
pub type ExprYieldFrom = crate::generic::ExprYieldFrom<SourceRange>;
impl Located for ExprYieldFrom {
fn range(&self) -> SourceRange {
self.range
}
}
pub type ExprCompare = crate::generic::ExprCompare<SourceRange>;
impl Located for ExprCompare {
fn range(&self) -> SourceRange {
self.range
}
}
pub type ExprCall = crate::generic::ExprCall<SourceRange>;
impl Located for ExprCall {
fn range(&self) -> SourceRange {
self.range
}
}
pub type ExprFormattedValue = crate::generic::ExprFormattedValue<SourceRange>;
impl Located for ExprFormattedValue {
fn range(&self) -> SourceRange {
self.range
}
}
pub type ExprJoinedStr = crate::generic::ExprJoinedStr<SourceRange>;
impl Located for ExprJoinedStr {
fn range(&self) -> SourceRange {
self.range
}
}
pub type ExprConstant = crate::generic::ExprConstant<SourceRange>;
impl Located for ExprConstant {
fn range(&self) -> SourceRange {
self.range
}
}
pub type ExprAttribute = crate::generic::ExprAttribute<SourceRange>;
impl Located for ExprAttribute {
fn range(&self) -> SourceRange {
self.range
}
}
pub type ExprSubscript = crate::generic::ExprSubscript<SourceRange>;
impl Located for ExprSubscript {
fn range(&self) -> SourceRange {
self.range
}
}
pub type ExprStarred = crate::generic::ExprStarred<SourceRange>;
impl Located for ExprStarred {
fn range(&self) -> SourceRange {
self.range
}
}
pub type ExprName = crate::generic::ExprName<SourceRange>;
impl Located for ExprName {
fn range(&self) -> SourceRange {
self.range
}
}
pub type ExprList = crate::generic::ExprList<SourceRange>;
impl Located for ExprList {
fn range(&self) -> SourceRange {
self.range
}
}
pub type ExprTuple = crate::generic::ExprTuple<SourceRange>;
impl Located for ExprTuple {
fn range(&self) -> SourceRange {
self.range
}
}
pub type ExprSlice = crate::generic::ExprSlice<SourceRange>;
impl Located for ExprSlice {
fn range(&self) -> SourceRange {
self.range
}
}
#[cfg(feature = "more-attributes")]
impl Located for Expr {
fn range(&self) -> SourceRange {
match self {
Self::BoolOp(node) => node.range(),
Self::NamedExpr(node) => node.range(),
Self::BinOp(node) => node.range(),
Self::UnaryOp(node) => node.range(),
Self::Lambda(node) => node.range(),
Self::IfExp(node) => node.range(),
Self::Dict(node) => node.range(),
Self::Set(node) => node.range(),
Self::ListComp(node) => node.range(),
Self::SetComp(node) => node.range(),
Self::DictComp(node) => node.range(),
Self::GeneratorExp(node) => node.range(),
Self::Await(node) => node.range(),
Self::Yield(node) => node.range(),
Self::YieldFrom(node) => node.range(),
Self::Compare(node) => node.range(),
Self::Call(node) => node.range(),
Self::FormattedValue(node) => node.range(),
Self::JoinedStr(node) => node.range(),
Self::Constant(node) => node.range(),
Self::Attribute(node) => node.range(),
Self::Subscript(node) => node.range(),
Self::Starred(node) => node.range(),
Self::Name(node) => node.range(),
Self::List(node) => node.range(),
Self::Tuple(node) => node.range(),
Self::Slice(node) => node.range(),
}
}
}
pub type ExprContext = crate::generic::ExprContext;
pub type Boolop = crate::generic::Boolop;
pub type Operator = crate::generic::Operator;
pub type Unaryop = crate::generic::Unaryop;
pub type Cmpop = crate::generic::Cmpop;
pub type Comprehension = crate::generic::Comprehension<SourceRange>;
#[cfg(feature = "more-attributes")]
impl Located for Comprehension {
fn range(&self) -> SourceRange {
self.range
}
}
pub type Excepthandler = crate::generic::Excepthandler<SourceRange>;
pub type ExcepthandlerExceptHandler = crate::generic::ExcepthandlerExceptHandler<SourceRange>;
impl Located for ExcepthandlerExceptHandler {
fn range(&self) -> SourceRange {
self.range
}
}
#[cfg(feature = "more-attributes")]
impl Located for Excepthandler {
fn range(&self) -> SourceRange {
match self {
Self::ExceptHandler(node) => node.range(),
}
}
}
pub type Arguments = crate::generic::Arguments<SourceRange>;
#[cfg(feature = "more-attributes")]
impl Located for Arguments {
fn range(&self) -> SourceRange {
self.range
}
}
pub type Arg = crate::generic::Arg<SourceRange>;
impl Located for Arg {
fn range(&self) -> SourceRange {
self.range
}
}
pub type Keyword = crate::generic::Keyword<SourceRange>;
impl Located for Keyword {
fn range(&self) -> SourceRange {
self.range
}
}
pub type Alias = crate::generic::Alias<SourceRange>;
impl Located for Alias {
fn range(&self) -> SourceRange {
self.range
}
}
#[cfg(feature = "more-attributes")]
pub type Withitem = crate::generic::Withitem<SourceRange>;
#[cfg(feature = "more-attributes")]
impl Located for Withitem {
fn range(&self) -> SourceRange {
self.range
}
}
#[cfg(feature = "more-attributes")]
pub type MatchCase = crate::generic::MatchCase<SourceRange>;
#[cfg(feature = "more-attributes")]
impl Located for MatchCase {
fn range(&self) -> SourceRange {
self.range
}
}
pub type Pattern = crate::generic::Pattern<SourceRange>;
pub type PatternMatchValue = crate::generic::PatternMatchValue<SourceRange>;
impl Located for PatternMatchValue {
fn range(&self) -> SourceRange {
self.range
}
}
pub type PatternMatchSingleton = crate::generic::PatternMatchSingleton<SourceRange>;
impl Located for PatternMatchSingleton {
fn range(&self) -> SourceRange {
self.range
}
}
pub type PatternMatchSequence = crate::generic::PatternMatchSequence<SourceRange>;
impl Located for PatternMatchSequence {
fn range(&self) -> SourceRange {
self.range
}
}
pub type PatternMatchMapping = crate::generic::PatternMatchMapping<SourceRange>;
impl Located for PatternMatchMapping {
fn range(&self) -> SourceRange {
self.range
}
}
pub type PatternMatchClass = crate::generic::PatternMatchClass<SourceRange>;
impl Located for PatternMatchClass {
fn range(&self) -> SourceRange {
self.range
}
}
pub type PatternMatchStar = crate::generic::PatternMatchStar<SourceRange>;
impl Located for PatternMatchStar {
fn range(&self) -> SourceRange {
self.range
}
}
pub type PatternMatchAs = crate::generic::PatternMatchAs<SourceRange>;
impl Located for PatternMatchAs {
fn range(&self) -> SourceRange {
self.range
}
}
pub type PatternMatchOr = crate::generic::PatternMatchOr<SourceRange>;
impl Located for PatternMatchOr {
fn range(&self) -> SourceRange {
self.range
}
}
#[cfg(feature = "more-attributes")]
impl Located for Pattern {
fn range(&self) -> SourceRange {
match self {
Self::MatchValue(node) => node.range(),
Self::MatchSingleton(node) => node.range(),
Self::MatchSequence(node) => node.range(),
Self::MatchMapping(node) => node.range(),
Self::MatchClass(node) => node.range(),
Self::MatchStar(node) => node.range(),
Self::MatchAs(node) => node.range(),
Self::MatchOr(node) => node.range(),
}
}
}
pub type TypeIgnore = crate::generic::TypeIgnore<SourceRange>;
pub type TypeIgnoreTypeIgnore = crate::generic::TypeIgnoreTypeIgnore<SourceRange>;
#[cfg(feature = "more-attributes")]
impl Located for TypeIgnoreTypeIgnore {
fn range(&self) -> SourceRange {
self.range
}
}
#[cfg(feature = "more-attributes")]
impl Located for TypeIgnore {
fn range(&self) -> SourceRange {
match self {
Self::TypeIgnore(node) => node.range(),
}
}
}

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

@ -25,6 +25,18 @@ impl Ranged for crate::generic::ModFunctionType<TextRange> {
self.range
}
}
#[cfg(feature = "more-attributes")]
impl Ranged for crate::Mod {
fn range(&self) -> TextRange {
match self {
Self::Module(node) => node.range(),
Self::Interactive(node) => node.range(),
Self::Expression(node) => node.range(),
Self::FunctionType(node) => node.range(),
}
}
}
impl Ranged for crate::generic::StmtFunctionDef<TextRange> {
fn range(&self) -> TextRange {
self.range
@ -160,6 +172,40 @@ impl Ranged for crate::generic::StmtContinue<TextRange> {
self.range
}
}
impl Ranged for crate::Stmt {
fn range(&self) -> TextRange {
match self {
Self::FunctionDef(node) => node.range(),
Self::AsyncFunctionDef(node) => node.range(),
Self::ClassDef(node) => node.range(),
Self::Return(node) => node.range(),
Self::Delete(node) => node.range(),
Self::Assign(node) => node.range(),
Self::AugAssign(node) => node.range(),
Self::AnnAssign(node) => node.range(),
Self::For(node) => node.range(),
Self::AsyncFor(node) => node.range(),
Self::While(node) => node.range(),
Self::If(node) => node.range(),
Self::With(node) => node.range(),
Self::AsyncWith(node) => node.range(),
Self::Match(node) => node.range(),
Self::Raise(node) => node.range(),
Self::Try(node) => node.range(),
Self::TryStar(node) => node.range(),
Self::Assert(node) => node.range(),
Self::Import(node) => node.range(),
Self::ImportFrom(node) => node.range(),
Self::Global(node) => node.range(),
Self::Nonlocal(node) => node.range(),
Self::Expr(node) => node.range(),
Self::Pass(node) => node.range(),
Self::Break(node) => node.range(),
Self::Continue(node) => node.range(),
}
}
}
impl Ranged for crate::generic::ExprBoolOp<TextRange> {
fn range(&self) -> TextRange {
self.range
@ -295,6 +341,40 @@ impl Ranged for crate::generic::ExprSlice<TextRange> {
self.range
}
}
impl Ranged for crate::Expr {
fn range(&self) -> TextRange {
match self {
Self::BoolOp(node) => node.range(),
Self::NamedExpr(node) => node.range(),
Self::BinOp(node) => node.range(),
Self::UnaryOp(node) => node.range(),
Self::Lambda(node) => node.range(),
Self::IfExp(node) => node.range(),
Self::Dict(node) => node.range(),
Self::Set(node) => node.range(),
Self::ListComp(node) => node.range(),
Self::SetComp(node) => node.range(),
Self::DictComp(node) => node.range(),
Self::GeneratorExp(node) => node.range(),
Self::Await(node) => node.range(),
Self::Yield(node) => node.range(),
Self::YieldFrom(node) => node.range(),
Self::Compare(node) => node.range(),
Self::Call(node) => node.range(),
Self::FormattedValue(node) => node.range(),
Self::JoinedStr(node) => node.range(),
Self::Constant(node) => node.range(),
Self::Attribute(node) => node.range(),
Self::Subscript(node) => node.range(),
Self::Starred(node) => node.range(),
Self::Name(node) => node.range(),
Self::List(node) => node.range(),
Self::Tuple(node) => node.range(),
Self::Slice(node) => node.range(),
}
}
}
#[cfg(feature = "more-attributes")]
impl Ranged for crate::generic::Comprehension<TextRange> {
fn range(&self) -> TextRange {
@ -306,6 +386,14 @@ impl Ranged for crate::generic::ExcepthandlerExceptHandler<TextRange> {
self.range
}
}
impl Ranged for crate::Excepthandler {
fn range(&self) -> TextRange {
match self {
Self::ExceptHandler(node) => node.range(),
}
}
}
#[cfg(feature = "more-attributes")]
impl Ranged for crate::generic::Arguments<TextRange> {
fn range(&self) -> TextRange {
@ -379,9 +467,32 @@ impl Ranged for crate::generic::PatternMatchOr<TextRange> {
self.range
}
}
impl Ranged for crate::Pattern {
fn range(&self) -> TextRange {
match self {
Self::MatchValue(node) => node.range(),
Self::MatchSingleton(node) => node.range(),
Self::MatchSequence(node) => node.range(),
Self::MatchMapping(node) => node.range(),
Self::MatchClass(node) => node.range(),
Self::MatchStar(node) => node.range(),
Self::MatchAs(node) => node.range(),
Self::MatchOr(node) => node.range(),
}
}
}
#[cfg(feature = "more-attributes")]
impl Ranged for crate::generic::TypeIgnoreTypeIgnore<TextRange> {
fn range(&self) -> TextRange {
self.range
}
}
#[cfg(feature = "more-attributes")]
impl Ranged for crate::TypeIgnore {
fn range(&self) -> TextRange {
match self {
Self::TypeIgnore(node) => node.range(),
}
}
}

98
ast/src/impls.rs
View file

@ -1,5 +1,5 @@
use crate::text_size::TextRange;
use crate::{Constant, Excepthandler, Expr, Pattern, Ranged, Stmt};
use crate::{Constant, Excepthandler, Expr, Pattern, Stmt};
use static_assertions::const_assert_eq;
impl<R> Expr<R> {
/// Returns a short name for the node suitable for use in error messages.
@ -55,93 +55,7 @@ impl<R> Expr<R> {
}
}
impl Ranged for Expr<TextRange> {
fn range(&self) -> TextRange {
match self {
Expr::BoolOp(node) => node.range(),
Expr::NamedExpr(node) => node.range(),
Expr::BinOp(node) => node.range(),
Expr::UnaryOp(node) => node.range(),
Expr::Lambda(node) => node.range(),
Expr::IfExp(node) => node.range(),
Expr::Dict(node) => node.range(),
Expr::Set(node) => node.range(),
Expr::ListComp(node) => node.range(),
Expr::SetComp(node) => node.range(),
Expr::DictComp(node) => node.range(),
Expr::GeneratorExp(node) => node.range(),
Expr::Await(node) => node.range(),
Expr::Yield(node) => node.range(),
Expr::YieldFrom(node) => node.range(),
Expr::Compare(node) => node.range(),
Expr::Call(node) => node.range(),
Expr::FormattedValue(node) => node.range(),
Expr::JoinedStr(node) => node.range(),
Expr::Constant(node) => node.range(),
Expr::Attribute(node) => node.range(),
Expr::Subscript(node) => node.range(),
Expr::Starred(node) => node.range(),
Expr::Name(node) => node.range(),
Expr::List(node) => node.range(),
Expr::Tuple(node) => node.range(),
Expr::Slice(node) => node.range(),
}
}
}
impl Ranged for Stmt<TextRange> {
fn range(&self) -> TextRange {
match self {
Stmt::FunctionDef(stmt) => stmt.range(),
Stmt::AsyncFunctionDef(stmt) => stmt.range(),
Stmt::ClassDef(stmt) => stmt.range(),
Stmt::Return(stmt) => stmt.range(),
Stmt::Delete(stmt) => stmt.range(),
Stmt::Assign(stmt) => stmt.range(),
Stmt::AugAssign(stmt) => stmt.range(),
Stmt::AnnAssign(stmt) => stmt.range(),
Stmt::For(stmt) => stmt.range(),
Stmt::AsyncFor(stmt) => stmt.range(),
Stmt::While(stmt) => stmt.range(),
Stmt::If(stmt) => stmt.range(),
Stmt::With(stmt) => stmt.range(),
Stmt::AsyncWith(stmt) => stmt.range(),
Stmt::Match(stmt) => stmt.range(),
Stmt::Raise(stmt) => stmt.range(),
Stmt::Try(stmt) => stmt.range(),
Stmt::TryStar(stmt) => stmt.range(),
Stmt::Assert(stmt) => stmt.range(),
Stmt::Import(stmt) => stmt.range(),
Stmt::ImportFrom(stmt) => stmt.range(),
Stmt::Global(stmt) => stmt.range(),
Stmt::Nonlocal(stmt) => stmt.range(),
Stmt::Expr(stmt) => stmt.range(),
Stmt::Pass(stmt) => stmt.range(),
Stmt::Break(stmt) => stmt.range(),
Stmt::Continue(stmt) => stmt.range(),
}
}
}
impl Ranged for Pattern<TextRange> {
fn range(&self) -> TextRange {
match self {
Pattern::MatchValue(pattern) => pattern.range(),
Pattern::MatchSingleton(pattern) => pattern.range(),
Pattern::MatchSequence(pattern) => pattern.range(),
Pattern::MatchMapping(pattern) => pattern.range(),
Pattern::MatchClass(pattern) => pattern.range(),
Pattern::MatchStar(pattern) => pattern.range(),
Pattern::MatchAs(pattern) => pattern.range(),
Pattern::MatchOr(pattern) => pattern.range(),
}
}
}
impl Ranged for Excepthandler<TextRange> {
fn range(&self) -> TextRange {
match self {
Excepthandler::ExceptHandler(handler) => handler.range(),
}
}
}
const_assert_eq!(std::mem::size_of::<Expr>(), 72);
const_assert_eq!(std::mem::size_of::<Stmt>(), 136);
const_assert_eq!(std::mem::size_of::<Pattern>(), 96);
const_assert_eq!(std::mem::size_of::<Excepthandler>(), 64);

5
ast/src/unparse.rs
View file

@ -389,10 +389,7 @@ impl<'a> Unparser<'a> {
self.unparse_expr(value, precedence::ATOM)?;
let mut lvl = precedence::TUPLE;
if let Expr::Tuple(crate::ExprTuple { elts, .. }) = slice.as_ref() {
if elts
.iter()
.any(|expr| expr.is_starred_expr())
{
if elts.iter().any(|expr| expr.is_starred_expr()) {
lvl += 1
}
}