Cleanup

ast/Cargo.toml

@@ -14,6 +14,7 @@ location = ["fold", "rustpython-parser-core/location"]
 fold = []
 unparse = ["rustpython-literal"]
 visitor = []
+more-attributes = []
 
 [dependencies]
 rustpython-parser-core = { workspace = true }

ast/asdl_rs.py

@@ -387,7 +387,7 @@ class StructVisitor(EmitVisitor):
         product_name = rust_type_name(name)
         self.emit_attrs(depth)
 
-        self.emit(f"pub struct {product_name}<R> {{", depth)
+        self.emit(f"pub struct {product_name}<R = TextRange> {{", depth)
         for f in product.fields:
             self.visit(f, type_info, "pub ", depth + 1)
         assert bool(product.attributes) == type_info.no_cfg(self.type_info)
@@ -657,7 +657,7 @@ class VisitorTraitDefVisitor(StructVisitor):
         self.emit_visitor(name, depth)
         self.emit_generic_visitor_signature(name, depth)
         depth += 1
-        self.emit("match node.node {", depth)
+        self.emit("match node {", depth)
         for t in sum.types:
             self.visit_match_for_type(name, enum_name, t, depth + 1)
         self.emit("}", depth)
@@ -925,7 +925,6 @@ class TraitImplVisitor(EmitVisitor):
             return f"Node::ast_from_object(_vm, get_node_field(_vm, &_object, {name}, {json.dumps(typename)})?)?"
 
 
-
 class RangedDefVisitor(EmitVisitor):
     def visitModule(self, mod):
         for dfn in mod.dfns:
@@ -937,41 +936,73 @@ class RangedDefVisitor(EmitVisitor):
     def visitSum(self, sum, name, depth):
         info = self.type_info[name]
 
-        # if info.is_simple:
-        #     return
+        if info.is_simple:
+            return
 
-        if not info.no_cfg(self.type_info):
-            self.emit('#[cfg(feature = "more-attributes")]', 0)
-
-        self.emit(
-            f"""
-                impl Ranged for crate::generic::{info.rust_sum_name}::<TextRange> {{
-                    fn range(&self) -> TextRange {{
-                        self.range
-                    }}
-                }}
-                """, 0)
+        for ty in sum.types:
+            info = self.type_info[ty.name]
+            self.make_ranged_impl(info)
 
     def visitProduct(self, product, name, depth):
         info = self.type_info[name]
 
-        # if info.is_simple:
-        #     return
+        self.make_ranged_impl(info)
+
+    def make_ranged_impl(self, info):
+        if not info.no_cfg(self.type_info):
+            self.emit('#[cfg(feature = "more-attributes")]', 0)
+
+        self.file.write(
+            f"""
+            impl Ranged for crate::generic::{info.rust_sum_name}::<TextRange> {{
+                fn range(&self) -> TextRange {{
+                    self.range
+                }}
+            }}
+            """.strip()
+        )
+
+class LocatedDefVisitor(EmitVisitor):
+    def visitModule(self, mod):
+        for dfn in mod.dfns:
+            self.visit(dfn)
+
+    def visitType(self, type, depth=0):
+        self.visit(type.value, type.name, depth)
+
+    def visitSum(self, sum, name, depth):
+        info = self.type_info[name]
+
+        if info.is_simple:
+            return
+
+        for ty in sum.types:
+            info = self.type_info[ty.name]
+            self.make_located_impl(info)
+
+    def visitProduct(self, product, name, depth):
+        info = self.type_info[name]
+
+        self.make_located_impl(info)
+
+    def make_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.emit(
+        self.file.write(
             f"""
-                    impl Ranged for crate::generic::{info.rust_sum_name}::<TextRange> {{
-                        fn range(&self) -> TextRange {{
-                            self.range
-                        }}
-                    }}
-                    """, 0)
-
-        for f in product.fields:
-            self.visit(f, info, "pub ", depth + 1)
+            impl Located for {info.rust_sum_name} {{
+                fn range(&self) -> SourceRange {{
+                    self.range
+                }}
+            }}
+            """.strip()
+        )
 
 class ChainOfVisitors:
     def __init__(self, *visitors):
@@ -997,40 +1028,12 @@ def write_visitor_def(mod, type_info, f):
 
 
 def write_ranged_def(mod, type_info, f):
+    f.write("use crate::Ranged;")
     RangedDefVisitor(f, type_info).visit(mod)
-# def write_ranged_def(mod, type_info, f):
-#     import pprint
-#     for info in type_info.values():
-#         pprint.pp(info.__dict__)
-#         if not info.is_simple and not info.product:
-#             if not info.no_cfg(type_info):
-#                 f.write('#[cfg(feature = "more-attributes")]')
-#             f.write(
-#                 f"""
-#             impl Ranged for crate::generic::{info.rust_sum_name}::<TextRange> {{
-#                 fn range(&self) -> TextRange {{
-#                     self.range
-#                 }}
-#             }}
-#             """
-#             )
 
 
 def write_located_def(mod, type_info, f):
-    for info in type_info.values():
-        if not info.is_simple:
-            if not info.no_cfg(type_info):
-                f.write('#[cfg(feature = "more-attributes")]')
-            f.write(
-                f"""
-            impl Located for crate::generic::{info.rust_sum_name}::<SourceRange> {{
-                fn range(&self) -> SourceRange {{
-                    self.range
-                }}
-            }}
-            """
-            )
-
+    LocatedDefVisitor(f, type_info).visit(mod)
 
 def write_ast_mod(mod, type_info, f):
     f.write(

ast/src/gen/generic.rs

@@ -964,7 +964,7 @@ pub enum Cmpop {
 }
 
 #[derive(Clone, Debug, PartialEq)]
-pub struct Comprehension<R> {
+pub struct Comprehension<R = TextRange> {
     pub target: Expr<R>,
     pub iter: Expr<R>,
     pub ifs: Vec<Expr<R>>,
@@ -995,7 +995,7 @@ pub enum Excepthandler<R = TextRange> {
 }
 
 #[derive(Clone, Debug, PartialEq)]
-pub struct Arguments<R> {
+pub struct Arguments<R = TextRange> {
     pub posonlyargs: Vec<Arg<R>>,
     pub args: Vec<Arg<R>>,
     pub vararg: Option<Box<Arg<R>>>,
@@ -1010,7 +1010,7 @@ pub struct Arguments<R> {
 }
 
 #[derive(Clone, Debug, PartialEq)]
-pub struct Arg<R> {
+pub struct Arg<R = TextRange> {
     pub arg: Identifier,
     pub annotation: Option<Box<Expr<R>>>,
     pub type_comment: Option<String>,
@@ -1018,21 +1018,21 @@ pub struct Arg<R> {
 }
 
 #[derive(Clone, Debug, PartialEq)]
-pub struct Keyword<R> {
+pub struct Keyword<R = TextRange> {
     pub arg: Option<Identifier>,
     pub value: Expr<R>,
     pub range: R,
 }
 
 #[derive(Clone, Debug, PartialEq)]
-pub struct Alias<R> {
+pub struct Alias<R = TextRange> {
     pub name: Identifier,
     pub asname: Option<Identifier>,
     pub range: R,
 }
 
 #[derive(Clone, Debug, PartialEq)]
-pub struct Withitem<R> {
+pub struct Withitem<R = TextRange> {
     pub context_expr: Expr<R>,
     pub optional_vars: Option<Box<Expr<R>>>,
     #[cfg(feature = "more-attributes")]
@@ -1042,7 +1042,7 @@ pub struct Withitem<R> {
 }
 
 #[derive(Clone, Debug, PartialEq)]
-pub struct MatchCase<R> {
+pub struct MatchCase<R = TextRange> {
     pub pattern: Pattern<R>,
     pub guard: Option<Box<Expr<R>>>,
     pub body: Vec<Stmt<R>>,

ast/src/gen/located.rs

@@ -1,487 +1,469 @@
 // File automatically generated by ast/asdl_rs.py.
 
 #[cfg(feature = "more-attributes")]
-impl Located for 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")]
-impl Located for crate::generic::ModModule<SourceRange> {
+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")]
-impl Located for crate::generic::ModInteractive<SourceRange> {
+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")]
-impl Located for crate::generic::ModExpression<SourceRange> {
+pub type ModFunctionType = crate::generic::ModFunctionType<SourceRange>;
+#[cfg(feature = "more-attributes")]
+impl Located for ModFunctionType {
+    fn range(&self) -> SourceRange {
+        self.range
+    }
+}
+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
+    }
+}
+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 crate::generic::ModFunctionType<SourceRange> {
+pub type Comprehension = crate::generic::Comprehension<SourceRange>;
+#[cfg(feature = "more-attributes")]
+impl Located for Comprehension {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
-
-impl Located for crate::generic::Stmt<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::StmtFunctionDef<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::StmtAsyncFunctionDef<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::StmtClassDef<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::StmtReturn<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::StmtDelete<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::StmtAssign<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::StmtAugAssign<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::StmtAnnAssign<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::StmtFor<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::StmtAsyncFor<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::StmtWhile<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::StmtIf<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::StmtWith<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::StmtAsyncWith<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::StmtMatch<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::StmtRaise<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::StmtTry<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::StmtTryStar<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::StmtAssert<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::StmtImport<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::StmtImportFrom<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::StmtGlobal<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::StmtNonlocal<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::StmtExpr<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::StmtPass<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::StmtBreak<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::StmtContinue<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::Expr<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::ExprBoolOp<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::ExprNamedExpr<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::ExprBinOp<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::ExprUnaryOp<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::ExprLambda<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::ExprIfExp<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::ExprDict<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::ExprSet<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::ExprListComp<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::ExprSetComp<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::ExprDictComp<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::ExprGeneratorExp<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::ExprAwait<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::ExprYield<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::ExprYieldFrom<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::ExprCompare<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::ExprCall<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::ExprFormattedValue<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::ExprJoinedStr<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::ExprConstant<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::ExprAttribute<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::ExprSubscript<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::ExprStarred<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::ExprName<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::ExprList<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::ExprTuple<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::ExprSlice<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 crate::generic::Comprehension<SourceRange> {
+pub type Arguments = crate::generic::Arguments<SourceRange>;
+#[cfg(feature = "more-attributes")]
+impl Located for Arguments {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
-
-impl Located for crate::generic::Excepthandler<SourceRange> {
+pub type Arg = crate::generic::Arg<SourceRange>;
+impl Located for Arg {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
-
-impl Located for crate::generic::ExcepthandlerExceptHandler<SourceRange> {
+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")]
-impl Located for crate::generic::Arguments<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::Arg<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::Keyword<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::Alias<SourceRange> {
+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")]
-impl Located for crate::generic::Withitem<SourceRange> {
+pub type MatchCase = crate::generic::MatchCase<SourceRange>;
+#[cfg(feature = "more-attributes")]
+impl Located for MatchCase {
+    fn range(&self) -> SourceRange {
+        self.range
+    }
+}
+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 crate::generic::MatchCase<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::Pattern<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::PatternMatchValue<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::PatternMatchSingleton<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::PatternMatchSequence<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::PatternMatchMapping<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::PatternMatchClass<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::PatternMatchStar<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::PatternMatchAs<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-
-impl Located for crate::generic::PatternMatchOr<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
+pub type TypeIgnoreTypeIgnore = crate::generic::TypeIgnoreTypeIgnore<SourceRange>;
 #[cfg(feature = "more-attributes")]
-impl Located for crate::generic::TypeIgnore<SourceRange> {
-    fn range(&self) -> SourceRange {
-        self.range
-    }
-}
-#[cfg(feature = "more-attributes")]
-impl Located for crate::generic::TypeIgnoreTypeIgnore<SourceRange> {
+impl Located for TypeIgnoreTypeIgnore {
     fn range(&self) -> SourceRange {
         self.range
     }

ast/src/gen/ranged.rs

@@ -1,130 +1,386 @@
 // File automatically generated by ast/asdl_rs.py.
 
+use crate::Ranged;
 #[cfg(feature = "more-attributes")]
-
-impl Ranged for crate::generic::Mod<TextRange> {
+impl Ranged for crate::generic::ModModule<TextRange> {
     fn range(&self) -> TextRange {
         self.range
     }
 }
-
-impl Ranged for crate::generic::Stmt<TextRange> {
-    fn range(&self) -> TextRange {
-        self.range
-    }
-}
-
-impl Ranged for crate::generic::Expr<TextRange> {
-    fn range(&self) -> TextRange {
-        self.range
-    }
-}
-
 #[cfg(feature = "more-attributes")]
-
-impl Ranged for crate::generic::ExprContext<TextRange> {
+impl Ranged for crate::generic::ModInteractive<TextRange> {
     fn range(&self) -> TextRange {
         self.range
     }
 }
-
 #[cfg(feature = "more-attributes")]
-
-impl Ranged for crate::generic::Boolop<TextRange> {
+impl Ranged for crate::generic::ModExpression<TextRange> {
     fn range(&self) -> TextRange {
         self.range
     }
 }
-
 #[cfg(feature = "more-attributes")]
-
-impl Ranged for crate::generic::Operator<TextRange> {
+impl Ranged for crate::generic::ModFunctionType<TextRange> {
     fn range(&self) -> TextRange {
         self.range
     }
 }
-
-#[cfg(feature = "more-attributes")]
-
-impl Ranged for crate::generic::Unaryop<TextRange> {
+impl Ranged for crate::generic::StmtFunctionDef<TextRange> {
     fn range(&self) -> TextRange {
         self.range
     }
 }
-
-#[cfg(feature = "more-attributes")]
-
-impl Ranged for crate::generic::Cmpop<TextRange> {
+impl Ranged for crate::generic::StmtAsyncFunctionDef<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::StmtClassDef<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::StmtReturn<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::StmtDelete<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::StmtAssign<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::StmtAugAssign<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::StmtAnnAssign<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::StmtFor<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::StmtAsyncFor<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::StmtWhile<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::StmtIf<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::StmtWith<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::StmtAsyncWith<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::StmtMatch<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::StmtRaise<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::StmtTry<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::StmtTryStar<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::StmtAssert<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::StmtImport<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::StmtImportFrom<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::StmtGlobal<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::StmtNonlocal<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::StmtExpr<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::StmtPass<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::StmtBreak<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::StmtContinue<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::ExprBoolOp<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::ExprNamedExpr<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::ExprBinOp<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::ExprUnaryOp<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::ExprLambda<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::ExprIfExp<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::ExprDict<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::ExprSet<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::ExprListComp<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::ExprSetComp<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::ExprDictComp<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::ExprGeneratorExp<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::ExprAwait<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::ExprYield<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::ExprYieldFrom<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::ExprCompare<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::ExprCall<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::ExprFormattedValue<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::ExprJoinedStr<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::ExprConstant<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::ExprAttribute<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::ExprSubscript<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::ExprStarred<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::ExprName<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::ExprList<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::ExprTuple<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::ExprSlice<TextRange> {
     fn range(&self) -> TextRange {
         self.range
     }
 }
-
 #[cfg(feature = "more-attributes")]
-
 impl Ranged for crate::generic::Comprehension<TextRange> {
     fn range(&self) -> TextRange {
         self.range
     }
 }
-
-impl Ranged for crate::generic::Excepthandler<TextRange> {
+impl Ranged for crate::generic::ExcepthandlerExceptHandler<TextRange> {
     fn range(&self) -> TextRange {
         self.range
     }
 }
-
 #[cfg(feature = "more-attributes")]
-
 impl Ranged for crate::generic::Arguments<TextRange> {
     fn range(&self) -> TextRange {
         self.range
     }
 }
-
 impl Ranged for crate::generic::Arg<TextRange> {
     fn range(&self) -> TextRange {
         self.range
     }
 }
-
 impl Ranged for crate::generic::Keyword<TextRange> {
     fn range(&self) -> TextRange {
         self.range
     }
 }
-
 impl Ranged for crate::generic::Alias<TextRange> {
     fn range(&self) -> TextRange {
         self.range
     }
 }
-
 #[cfg(feature = "more-attributes")]
-
 impl Ranged for crate::generic::Withitem<TextRange> {
     fn range(&self) -> TextRange {
         self.range
     }
 }
-
 #[cfg(feature = "more-attributes")]
-
 impl Ranged for crate::generic::MatchCase<TextRange> {
     fn range(&self) -> TextRange {
         self.range
     }
 }
-
-impl Ranged for crate::generic::Pattern<TextRange> {
+impl Ranged for crate::generic::PatternMatchValue<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::PatternMatchSingleton<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::PatternMatchSequence<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::PatternMatchMapping<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::PatternMatchClass<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::PatternMatchStar<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::PatternMatchAs<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::PatternMatchOr<TextRange> {
     fn range(&self) -> TextRange {
         self.range
     }
 }
-
 #[cfg(feature = "more-attributes")]
-
-impl Ranged for crate::generic::TypeIgnore<TextRange> {
+impl Ranged for crate::generic::TypeIgnoreTypeIgnore<TextRange> {
     fn range(&self) -> TextRange {
         self.range
     }

ast/src/gen/visitor.rs

@@ -6,7 +6,7 @@ pub trait Visitor<R = crate::text_size::TextRange> {
         self.generic_visit_stmt(node)
     }
     fn generic_visit_stmt(&mut self, node: Stmt<R>) {
-        match node.node {
+        match node {
             Stmt::FunctionDef(data) => self.visit_stmt_FunctionDef(data),
             Stmt::AsyncFunctionDef(data) => self.visit_stmt_AsyncFunctionDef(data),
             Stmt::ClassDef(data) => self.visit_stmt_ClassDef(data),
@@ -345,7 +345,7 @@ pub trait Visitor<R = crate::text_size::TextRange> {
         self.generic_visit_expr(node)
     }
     fn generic_visit_expr(&mut self, node: Expr<R>) {
-        match node.node {
+        match node {
             Expr::BoolOp(data) => self.visit_expr_BoolOp(data),
             Expr::NamedExpr(data) => self.visit_expr_NamedExpr(data),
             Expr::BinOp(data) => self.visit_expr_BinOp(data),
@@ -689,7 +689,7 @@ pub trait Visitor<R = crate::text_size::TextRange> {
         self.generic_visit_excepthandler(node)
     }
     fn generic_visit_excepthandler(&mut self, node: Excepthandler<R>) {
-        match node.node {
+        match node {
             Excepthandler::ExceptHandler(data) => self.visit_excepthandler_ExceptHandler(data),
         }
     }
@@ -732,7 +732,7 @@ pub trait Visitor<R = crate::text_size::TextRange> {
         self.generic_visit_pattern(node)
     }
     fn generic_visit_pattern(&mut self, node: Pattern<R>) {
-        match node.node {
+        match node {
             Pattern::MatchValue(data) => self.visit_pattern_MatchValue(data),
             Pattern::MatchSingleton(data) => self.visit_pattern_MatchSingleton(data),
             Pattern::MatchSequence(data) => self.visit_pattern_MatchSequence(data),

ast/src/impls.rs

@@ -1,6 +1,5 @@
-use crate::ranged::Ranged;
 use crate::text_size::TextRange;
-use crate::{Constant, Excepthandler, Expr, Pattern, Stmt};
+use crate::{Constant, Excepthandler, Expr, Pattern, Ranged, Stmt};
 
 impl<R> Expr<R> {
     /// Returns a short name for the node suitable for use in error messages.
@@ -41,10 +40,7 @@ impl<R> Expr<R> {
             Expr::Starred { .. } => "starred",
             Expr::Slice { .. } => "slice",
             Expr::JoinedStr(crate::ExprJoinedStr { values, .. }) => {
-                if values
-                    .iter()
-                    .any(|e| matches!(e.node, Expr::JoinedStr { .. }))
-                {
+                if values.iter().any(|e| e.is_joined_str_expr()) {
                     "f-string expression"
                 } else {
                     "literal"

ast/src/lib.rs

@@ -1,7 +1,7 @@
 mod builtin;
 #[cfg(feature = "fold")]
 mod fold_helpers;
-pub mod generic {
+mod generic {
     #![allow(clippy::derive_partial_eq_without_eq)]
     pub use crate::builtin::*;
 
@@ -18,7 +18,7 @@ pub use builtin::*;
 pub use generic::*;
 pub use rustpython_parser_core::{text_size, ConversionFlag};
 
-pub type Suite<U = ()> = Vec<Stmt<U>>;
+pub type Suite<R = TextRange> = Vec<Stmt<R>>;
 
 #[cfg(feature = "fold")]
 pub mod fold {
@@ -41,8 +41,21 @@ pub use rustpython_parser_core::source_code;
 #[cfg(feature = "visitor")]
 pub use visitor::Visitor;
 
+pub trait Ranged {
+    fn range(&self) -> TextRange;
+
+    fn start(&self) -> TextSize {
+        self.range().start()
+    }
+
+    fn end(&self) -> TextSize {
+        self.range().end()
+    }
+}
+
 #[cfg(feature = "constant-optimization")]
 mod optimizer;
 
 #[cfg(feature = "constant-optimization")]
 pub use optimizer::ConstantOptimizer;
+use rustpython_parser_core::text_size::{TextRange, TextSize};

ast/src/optimizer.rs

@@ -20,19 +20,16 @@ impl<U> crate::fold::Fold<U> for ConstantOptimizer {
         Ok(user)
     }
     fn fold_expr(&mut self, node: crate::Expr<U>) -> Result<crate::Expr<U>, Self::Error> {
-        match node.node {
+        match node {
             crate::Expr::Tuple(crate::ExprTuple { elts, ctx, range }) => {
                 let elts = elts
                     .into_iter()
                     .map(|x| self.fold_expr(x))
                     .collect::<Result<Vec<_>, _>>()?;
-                let expr = if elts
-                    .iter()
-                    .all(|e| matches!(e.node, crate::Expr::Constant { .. }))
-                {
+                let expr = if elts.iter().all(|e| e.is_constant_expr()) {
                     let tuple = elts
                         .into_iter()
-                        .map(|e| match e.node {
+                        .map(|e| match e {
                             crate::Expr::Constant(crate::ExprConstant { value, .. }) => value,
                             _ => unreachable!(),
                         })
@@ -55,7 +52,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]
@@ -63,8 +59,6 @@ mod tests {
         use crate::{fold::Fold, *};
 
         let range = TextRange::default();
-        #[allow(clippy::let_unit_value)]
-        let custom = ();
         let ast = ExprTuple {
             ctx: ExprContext::Load,
             elts: vec![
@@ -72,12 +66,14 @@ mod tests {
                     value: BigInt::from(1).into(),
                     kind: None,
                     range,
-                },
+                }
+                .into(),
                 ExprConstant {
                     value: BigInt::from(2).into(),
                     kind: None,
                     range,
-                },
+                }
+                .into(),
                 ExprTuple {
                     ctx: ExprContext::Load,
                     elts: vec![
@@ -101,12 +97,13 @@ mod tests {
                         .into(),
                     ],
                     range,
-                },
+                }
+                .into(),
             ],
             range,
         };
         let new_ast = ConstantOptimizer::new()
-            .fold_expr(ast)
+            .fold_expr(ast.into())
             .unwrap_or_else(|e| match e {});
         assert_eq!(
             new_ast,

ast/src/ranged.rs

@@ -1,16 +1,4 @@
-use crate::text_size::{TextRange, TextSize};
-
-pub trait Ranged {
-    fn range(&self) -> TextRange;
-
-    fn start(&self) -> TextSize {
-        self.range().start()
-    }
-
-    fn end(&self) -> TextSize {
-        self.range().end()
-    }
-}
+use crate::text_size::TextRange;
 
 pub use crate::builtin::*;
 include!("gen/ranged.rs");

ast/src/unparse.rs

@@ -71,7 +71,7 @@ impl<'a> Unparser<'a> {
                 ret
             }};
         }
-        match &ast.node {
+        match &ast {
             Expr::BoolOp(crate::ExprBoolOp {
                 op,
                 values,
@@ -330,13 +330,13 @@ impl<'a> Unparser<'a> {
                     }
                     for kw in keywords {
                         self.p_delim(&mut first, ", ")?;
-                        if let Some(arg) = &kw.node.arg {
+                        if let Some(arg) = &kw.arg {
                             self.p_id(arg)?;
                             self.p("=")?;
                         } else {
                             self.p("**")?;
                         }
-                        self.unparse_expr(&kw.node.value, precedence::TEST)?;
+                        self.unparse_expr(&kw.value, precedence::TEST)?;
                     }
                 }
                 self.p(")")?;
@@ -376,7 +376,7 @@ impl<'a> Unparser<'a> {
                 let period = if let Expr::Constant(crate::ExprConstant {
                     value: Constant::Int(_),
                     ..
-                }) = &value.node
+                }) = value.as_ref()
                 {
                     " ."
                 } else {
@@ -388,10 +388,10 @@ impl<'a> Unparser<'a> {
             Expr::Subscript(crate::ExprSubscript { value, slice, .. }) => {
                 self.unparse_expr(value, precedence::ATOM)?;
                 let mut lvl = precedence::TUPLE;
-                if let Expr::Tuple(crate::ExprTuple { elts, .. }) = &slice.node {
+                if let Expr::Tuple(crate::ExprTuple { elts, .. }) = slice.as_ref() {
                     if elts
                         .iter()
-                        .any(|expr| matches!(expr.node, Expr::Starred { .. }))
+                        .any(|expr| expr.is_starred_expr())
                     {
                         lvl += 1
                     }
@@ -487,8 +487,8 @@ impl<'a> Unparser<'a> {
         Ok(())
     }
     fn unparse_arg<U>(&mut self, arg: &Arg<U>) -> fmt::Result {
-        self.p_id(&arg.node.arg)?;
-        if let Some(ann) = &arg.node.annotation {
+        self.p_id(&arg.arg)?;
+        if let Some(ann) = &arg.annotation {
             write!(self, ": {}", **ann)?;
         }
         Ok(())
@@ -554,7 +554,7 @@ impl<'a> Unparser<'a> {
     }
 
     fn unparse_fstring_elem<U>(&mut self, expr: &Expr<U>, is_spec: bool) -> fmt::Result {
-        match &expr.node {
+        match &expr {
             Expr::Constant(crate::ExprConstant { value, .. }) => {
                 if let Constant::Str(s) = value {
                     self.unparse_fstring_str(s)