Move range from Attributed to Nodes (#22)

* Move `range` from `Attributed` to `Node`s

* No Attributed + custom for Range PoC

* Generate all located variants, generate enum implementations

* Implement `Copy` on simple enums

* Move `Suite` to `ranged` and `located`

* Update tests
---------

Co-authored-by: Jeong YunWon <jeong@youknowone.org>

ast/src/builtin.rs

@@ -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;
 
@@ -205,64 +204,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,
-}
-
-impl<T, U> Attributed<T, U> {
-    /// Returns the node
-    #[inline]
-    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 {
-        Self {
-            range: range.into(),
-            custom: (),
-            node: node.into(),
-        }
-    }
-
-    /// Consumes self and returns the node.
-    #[inline]
-    pub fn into_node(self) -> T {
-        self.node
-    }
-}
-
-impl<T, U> std::ops::Deref for Attributed<T, U> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        &self.node
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

ast/src/gen/located.rs

@@ -1,95 +1,753 @@
 // File automatically generated by ast/asdl_rs.py.
 
-use rustpython_parser_core::source_code::SourceRange;
+pub type Mod = crate::generic::Mod<SourceRange>;
 
-pub type Located<T> = super::generic::Attributed<T, SourceRange>;
-pub type Mod = super::generic::Mod<SourceRange>;
-pub type ModModule = super::generic::ModModule<SourceRange>;
-pub type ModInteractive = super::generic::ModInteractive<SourceRange>;
-pub type ModExpression = super::generic::ModExpression<SourceRange>;
-pub type ModFunctionType = super::generic::ModFunctionType<SourceRange>;
-pub type Stmt = super::generic::Stmt<SourceRange>;
-pub type StmtKind = super::generic::StmtKind<SourceRange>;
-pub type StmtFunctionDef = super::generic::StmtFunctionDef<SourceRange>;
-pub type StmtAsyncFunctionDef = super::generic::StmtAsyncFunctionDef<SourceRange>;
-pub type StmtClassDef = super::generic::StmtClassDef<SourceRange>;
-pub type StmtReturn = super::generic::StmtReturn<SourceRange>;
-pub type StmtDelete = super::generic::StmtDelete<SourceRange>;
-pub type StmtAssign = super::generic::StmtAssign<SourceRange>;
-pub type StmtAugAssign = super::generic::StmtAugAssign<SourceRange>;
-pub type StmtAnnAssign = super::generic::StmtAnnAssign<SourceRange>;
-pub type StmtFor = super::generic::StmtFor<SourceRange>;
-pub type StmtAsyncFor = super::generic::StmtAsyncFor<SourceRange>;
-pub type StmtWhile = super::generic::StmtWhile<SourceRange>;
-pub type StmtIf = super::generic::StmtIf<SourceRange>;
-pub type StmtWith = super::generic::StmtWith<SourceRange>;
-pub type StmtAsyncWith = super::generic::StmtAsyncWith<SourceRange>;
-pub type StmtMatch = super::generic::StmtMatch<SourceRange>;
-pub type StmtRaise = super::generic::StmtRaise<SourceRange>;
-pub type StmtTry = super::generic::StmtTry<SourceRange>;
-pub type StmtTryStar = super::generic::StmtTryStar<SourceRange>;
-pub type StmtAssert = super::generic::StmtAssert<SourceRange>;
-pub type StmtImport = super::generic::StmtImport<SourceRange>;
-pub type StmtImportFrom = super::generic::StmtImportFrom<SourceRange>;
-pub type StmtGlobal = super::generic::StmtGlobal;
-pub type StmtNonlocal = super::generic::StmtNonlocal;
-pub type StmtExpr = super::generic::StmtExpr<SourceRange>;
-pub type Expr = super::generic::Expr<SourceRange>;
-pub type ExprKind = super::generic::ExprKind<SourceRange>;
-pub type ExprBoolOp = super::generic::ExprBoolOp<SourceRange>;
-pub type ExprNamedExpr = super::generic::ExprNamedExpr<SourceRange>;
-pub type ExprBinOp = super::generic::ExprBinOp<SourceRange>;
-pub type ExprUnaryOp = super::generic::ExprUnaryOp<SourceRange>;
-pub type ExprLambda = super::generic::ExprLambda<SourceRange>;
-pub type ExprIfExp = super::generic::ExprIfExp<SourceRange>;
-pub type ExprDict = super::generic::ExprDict<SourceRange>;
-pub type ExprSet = super::generic::ExprSet<SourceRange>;
-pub type ExprListComp = super::generic::ExprListComp<SourceRange>;
-pub type ExprSetComp = super::generic::ExprSetComp<SourceRange>;
-pub type ExprDictComp = super::generic::ExprDictComp<SourceRange>;
-pub type ExprGeneratorExp = super::generic::ExprGeneratorExp<SourceRange>;
-pub type ExprAwait = super::generic::ExprAwait<SourceRange>;
-pub type ExprYield = super::generic::ExprYield<SourceRange>;
-pub type ExprYieldFrom = super::generic::ExprYieldFrom<SourceRange>;
-pub type ExprCompare = super::generic::ExprCompare<SourceRange>;
-pub type ExprCall = super::generic::ExprCall<SourceRange>;
-pub type ExprFormattedValue = super::generic::ExprFormattedValue<SourceRange>;
-pub type ExprJoinedStr = super::generic::ExprJoinedStr<SourceRange>;
-pub type ExprConstant = super::generic::ExprConstant;
-pub type ExprAttribute = super::generic::ExprAttribute<SourceRange>;
-pub type ExprSubscript = super::generic::ExprSubscript<SourceRange>;
-pub type ExprStarred = super::generic::ExprStarred<SourceRange>;
-pub type ExprName = super::generic::ExprName;
-pub type ExprList = super::generic::ExprList<SourceRange>;
-pub type ExprTuple = super::generic::ExprTuple<SourceRange>;
-pub type ExprSlice = super::generic::ExprSlice<SourceRange>;
-pub type ExprContext = super::generic::ExprContext;
-pub type Boolop = super::generic::Boolop;
-pub type Operator = super::generic::Operator;
-pub type Unaryop = super::generic::Unaryop;
-pub type Cmpop = super::generic::Cmpop;
-pub type Comprehension = super::generic::Comprehension<SourceRange>;
-pub type Excepthandler = super::generic::Excepthandler<SourceRange>;
-pub type ExcepthandlerKind = super::generic::ExcepthandlerKind<SourceRange>;
-pub type ExcepthandlerExceptHandler = super::generic::ExcepthandlerExceptHandler<SourceRange>;
-pub type Arguments = super::generic::Arguments<SourceRange>;
-pub type Arg = super::generic::Arg<SourceRange>;
-pub type ArgData = super::generic::ArgData<SourceRange>;
-pub type Keyword = super::generic::Keyword<SourceRange>;
-pub type KeywordData = super::generic::KeywordData<SourceRange>;
-pub type Alias = super::generic::Alias<SourceRange>;
-pub type AliasData = super::generic::AliasData;
-pub type Withitem = super::generic::Withitem<SourceRange>;
-pub type MatchCase = super::generic::MatchCase<SourceRange>;
-pub type Pattern = super::generic::Pattern<SourceRange>;
-pub type PatternKind = super::generic::PatternKind<SourceRange>;
-pub type PatternMatchValue = super::generic::PatternMatchValue<SourceRange>;
-pub type PatternMatchSingleton = super::generic::PatternMatchSingleton;
-pub type PatternMatchSequence = super::generic::PatternMatchSequence<SourceRange>;
-pub type PatternMatchMapping = super::generic::PatternMatchMapping<SourceRange>;
-pub type PatternMatchClass = super::generic::PatternMatchClass<SourceRange>;
-pub type PatternMatchStar = super::generic::PatternMatchStar;
-pub type PatternMatchAs = super::generic::PatternMatchAs<SourceRange>;
-pub type PatternMatchOr = super::generic::PatternMatchOr<SourceRange>;
-pub type TypeIgnore = super::generic::TypeIgnore;
-pub type TypeIgnoreTypeIgnore = super::generic::TypeIgnoreTypeIgnore;
+pub type ModModule = crate::generic::ModModule<SourceRange>;
+
+#[cfg(feature = "all-nodes-with-ranges")]
+
+impl Located for ModModule {
+    fn range(&self) -> SourceRange {
+        self.range
+    }
+}
+
+pub type ModInteractive = crate::generic::ModInteractive<SourceRange>;
+
+#[cfg(feature = "all-nodes-with-ranges")]
+
+impl Located for ModInteractive {
+    fn range(&self) -> SourceRange {
+        self.range
+    }
+}
+
+pub type ModExpression = crate::generic::ModExpression<SourceRange>;
+
+#[cfg(feature = "all-nodes-with-ranges")]
+
+impl Located for ModExpression {
+    fn range(&self) -> SourceRange {
+        self.range
+    }
+}
+
+pub type ModFunctionType = crate::generic::ModFunctionType<SourceRange>;
+
+#[cfg(feature = "all-nodes-with-ranges")]
+
+impl Located for ModFunctionType {
+    fn range(&self) -> SourceRange {
+        self.range
+    }
+}
+
+#[cfg(feature = "all-nodes-with-ranges")]
+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
+    }
+}
+
+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 = "all-nodes-with-ranges")]
+
+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
+    }
+}
+
+impl Located for Excepthandler {
+    fn range(&self) -> SourceRange {
+        match self {
+            Self::ExceptHandler(node) => node.range(),
+        }
+    }
+}
+
+pub type Arguments = crate::generic::Arguments<SourceRange>;
+
+#[cfg(feature = "all-nodes-with-ranges")]
+
+impl Located for Arguments {
+    fn range(&self) -> SourceRange {
+        self.range
+    }
+}
+
+pub type 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
+    }
+}
+
+pub type Withitem = crate::generic::Withitem<SourceRange>;
+
+#[cfg(feature = "all-nodes-with-ranges")]
+
+impl Located for Withitem {
+    fn range(&self) -> SourceRange {
+        self.range
+    }
+}
+
+pub type MatchCase = crate::generic::MatchCase<SourceRange>;
+
+#[cfg(feature = "all-nodes-with-ranges")]
+
+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
+    }
+}
+
+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 = "all-nodes-with-ranges")]
+
+impl Located for TypeIgnoreTypeIgnore {
+    fn range(&self) -> SourceRange {
+        self.range
+    }
+}
+
+#[cfg(feature = "all-nodes-with-ranges")]
+impl Located for TypeIgnore {
+    fn range(&self) -> SourceRange {
+        match self {
+            Self::TypeIgnore(node) => node.range(),
+        }
+    }
+}

ast/src/gen/ranged.rs

@@ -0,0 +1,497 @@
+// File automatically generated by ast/asdl_rs.py.
+
+#[cfg(feature = "all-nodes-with-ranges")]
+impl Ranged for crate::generic::ModModule<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+#[cfg(feature = "all-nodes-with-ranges")]
+impl Ranged for crate::generic::ModInteractive<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+#[cfg(feature = "all-nodes-with-ranges")]
+impl Ranged for crate::generic::ModExpression<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+#[cfg(feature = "all-nodes-with-ranges")]
+impl Ranged for crate::generic::ModFunctionType<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+#[cfg(feature = "all-nodes-with-ranges")]
+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
+    }
+}
+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::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
+    }
+}
+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
+    }
+}
+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 = "all-nodes-with-ranges")]
+impl Ranged for crate::generic::Comprehension<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::ExcepthandlerExceptHandler<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::Excepthandler {
+    fn range(&self) -> TextRange {
+        match self {
+            Self::ExceptHandler(node) => node.range(),
+        }
+    }
+}
+
+#[cfg(feature = "all-nodes-with-ranges")]
+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 = "all-nodes-with-ranges")]
+impl Ranged for crate::generic::Withitem<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+#[cfg(feature = "all-nodes-with-ranges")]
+impl Ranged for crate::generic::MatchCase<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+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
+    }
+}
+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 = "all-nodes-with-ranges")]
+impl Ranged for crate::generic::TypeIgnoreTypeIgnore<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+#[cfg(feature = "all-nodes-with-ranges")]
+impl Ranged for crate::TypeIgnore {
+    fn range(&self) -> TextRange {
+        match self {
+            Self::TypeIgnore(node) => node.range(),
+        }
+    }
+}

ast/src/gen/visitor.rs

@@ -1,45 +1,45 @@
 // File automatically generated by ast/asdl_rs.py.
 
 #[allow(unused_variables, non_snake_case)]
-pub trait Visitor<U = ()> {
-    fn visit_stmt(&mut self, node: Stmt) {
+pub trait Visitor<R = crate::text_size::TextRange> {
+    fn visit_stmt(&mut self, node: Stmt<R>) {
         self.generic_visit_stmt(node)
     }
-    fn generic_visit_stmt(&mut self, node: Stmt) {
-        match node.node {
-            StmtKind::FunctionDef(data) => self.visit_stmt_FunctionDef(data),
-            StmtKind::AsyncFunctionDef(data) => self.visit_stmt_AsyncFunctionDef(data),
-            StmtKind::ClassDef(data) => self.visit_stmt_ClassDef(data),
-            StmtKind::Return(data) => self.visit_stmt_Return(data),
-            StmtKind::Delete(data) => self.visit_stmt_Delete(data),
-            StmtKind::Assign(data) => self.visit_stmt_Assign(data),
-            StmtKind::AugAssign(data) => self.visit_stmt_AugAssign(data),
-            StmtKind::AnnAssign(data) => self.visit_stmt_AnnAssign(data),
-            StmtKind::For(data) => self.visit_stmt_For(data),
-            StmtKind::AsyncFor(data) => self.visit_stmt_AsyncFor(data),
-            StmtKind::While(data) => self.visit_stmt_While(data),
-            StmtKind::If(data) => self.visit_stmt_If(data),
-            StmtKind::With(data) => self.visit_stmt_With(data),
-            StmtKind::AsyncWith(data) => self.visit_stmt_AsyncWith(data),
-            StmtKind::Match(data) => self.visit_stmt_Match(data),
-            StmtKind::Raise(data) => self.visit_stmt_Raise(data),
-            StmtKind::Try(data) => self.visit_stmt_Try(data),
-            StmtKind::TryStar(data) => self.visit_stmt_TryStar(data),
-            StmtKind::Assert(data) => self.visit_stmt_Assert(data),
-            StmtKind::Import(data) => self.visit_stmt_Import(data),
-            StmtKind::ImportFrom(data) => self.visit_stmt_ImportFrom(data),
-            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(()),
+    fn generic_visit_stmt(&mut self, node: Stmt<R>) {
+        match node {
+            Stmt::FunctionDef(data) => self.visit_stmt_FunctionDef(data),
+            Stmt::AsyncFunctionDef(data) => self.visit_stmt_AsyncFunctionDef(data),
+            Stmt::ClassDef(data) => self.visit_stmt_ClassDef(data),
+            Stmt::Return(data) => self.visit_stmt_Return(data),
+            Stmt::Delete(data) => self.visit_stmt_Delete(data),
+            Stmt::Assign(data) => self.visit_stmt_Assign(data),
+            Stmt::AugAssign(data) => self.visit_stmt_AugAssign(data),
+            Stmt::AnnAssign(data) => self.visit_stmt_AnnAssign(data),
+            Stmt::For(data) => self.visit_stmt_For(data),
+            Stmt::AsyncFor(data) => self.visit_stmt_AsyncFor(data),
+            Stmt::While(data) => self.visit_stmt_While(data),
+            Stmt::If(data) => self.visit_stmt_If(data),
+            Stmt::With(data) => self.visit_stmt_With(data),
+            Stmt::AsyncWith(data) => self.visit_stmt_AsyncWith(data),
+            Stmt::Match(data) => self.visit_stmt_Match(data),
+            Stmt::Raise(data) => self.visit_stmt_Raise(data),
+            Stmt::Try(data) => self.visit_stmt_Try(data),
+            Stmt::TryStar(data) => self.visit_stmt_TryStar(data),
+            Stmt::Assert(data) => self.visit_stmt_Assert(data),
+            Stmt::Import(data) => self.visit_stmt_Import(data),
+            Stmt::ImportFrom(data) => self.visit_stmt_ImportFrom(data),
+            Stmt::Global(data) => self.visit_stmt_Global(data),
+            Stmt::Nonlocal(data) => self.visit_stmt_Nonlocal(data),
+            Stmt::Expr(data) => self.visit_stmt_Expr(data),
+            Stmt::Pass(data) => self.visit_stmt_Pass(data),
+            Stmt::Break(data) => self.visit_stmt_Break(data),
+            Stmt::Continue(data) => self.visit_stmt_Continue(data),
         }
     }
-    fn visit_stmt_FunctionDef(&mut self, node: StmtFunctionDef) {
+    fn visit_stmt_FunctionDef(&mut self, node: StmtFunctionDef<R>) {
         self.generic_visit_stmt_FunctionDef(node)
     }
-    fn generic_visit_stmt_FunctionDef(&mut self, node: StmtFunctionDef) {
+    fn generic_visit_stmt_FunctionDef(&mut self, node: StmtFunctionDef<R>) {
         {
             let value = node.args;
             self.visit_arguments(*value);
@@ -54,10 +54,10 @@ pub trait Visitor<U = ()> {
             self.visit_expr(*value);
         }
     }
-    fn visit_stmt_AsyncFunctionDef(&mut self, node: StmtAsyncFunctionDef) {
+    fn visit_stmt_AsyncFunctionDef(&mut self, node: StmtAsyncFunctionDef<R>) {
         self.generic_visit_stmt_AsyncFunctionDef(node)
     }
-    fn generic_visit_stmt_AsyncFunctionDef(&mut self, node: StmtAsyncFunctionDef) {
+    fn generic_visit_stmt_AsyncFunctionDef(&mut self, node: StmtAsyncFunctionDef<R>) {
         {
             let value = node.args;
             self.visit_arguments(*value);
@@ -72,10 +72,10 @@ pub trait Visitor<U = ()> {
             self.visit_expr(*value);
         }
     }
-    fn visit_stmt_ClassDef(&mut self, node: StmtClassDef) {
+    fn visit_stmt_ClassDef(&mut self, node: StmtClassDef<R>) {
         self.generic_visit_stmt_ClassDef(node)
     }
-    fn generic_visit_stmt_ClassDef(&mut self, node: StmtClassDef) {
+    fn generic_visit_stmt_ClassDef(&mut self, node: StmtClassDef<R>) {
         for value in node.bases {
             self.visit_expr(value);
         }
@@ -89,26 +89,26 @@ pub trait Visitor<U = ()> {
             self.visit_expr(value);
         }
     }
-    fn visit_stmt_Return(&mut self, node: StmtReturn) {
+    fn visit_stmt_Return(&mut self, node: StmtReturn<R>) {
         self.generic_visit_stmt_Return(node)
     }
-    fn generic_visit_stmt_Return(&mut self, node: StmtReturn) {
+    fn generic_visit_stmt_Return(&mut self, node: StmtReturn<R>) {
         if let Some(value) = node.value {
             self.visit_expr(*value);
         }
     }
-    fn visit_stmt_Delete(&mut self, node: StmtDelete) {
+    fn visit_stmt_Delete(&mut self, node: StmtDelete<R>) {
         self.generic_visit_stmt_Delete(node)
     }
-    fn generic_visit_stmt_Delete(&mut self, node: StmtDelete) {
+    fn generic_visit_stmt_Delete(&mut self, node: StmtDelete<R>) {
         for value in node.targets {
             self.visit_expr(value);
         }
     }
-    fn visit_stmt_Assign(&mut self, node: StmtAssign) {
+    fn visit_stmt_Assign(&mut self, node: StmtAssign<R>) {
         self.generic_visit_stmt_Assign(node)
     }
-    fn generic_visit_stmt_Assign(&mut self, node: StmtAssign) {
+    fn generic_visit_stmt_Assign(&mut self, node: StmtAssign<R>) {
         for value in node.targets {
             self.visit_expr(value);
         }
@@ -117,10 +117,10 @@ pub trait Visitor<U = ()> {
             self.visit_expr(*value);
         }
     }
-    fn visit_stmt_AugAssign(&mut self, node: StmtAugAssign) {
+    fn visit_stmt_AugAssign(&mut self, node: StmtAugAssign<R>) {
         self.generic_visit_stmt_AugAssign(node)
     }
-    fn generic_visit_stmt_AugAssign(&mut self, node: StmtAugAssign) {
+    fn generic_visit_stmt_AugAssign(&mut self, node: StmtAugAssign<R>) {
         {
             let value = node.target;
             self.visit_expr(*value);
@@ -130,10 +130,10 @@ pub trait Visitor<U = ()> {
             self.visit_expr(*value);
         }
     }
-    fn visit_stmt_AnnAssign(&mut self, node: StmtAnnAssign) {
+    fn visit_stmt_AnnAssign(&mut self, node: StmtAnnAssign<R>) {
         self.generic_visit_stmt_AnnAssign(node)
     }
-    fn generic_visit_stmt_AnnAssign(&mut self, node: StmtAnnAssign) {
+    fn generic_visit_stmt_AnnAssign(&mut self, node: StmtAnnAssign<R>) {
         {
             let value = node.target;
             self.visit_expr(*value);
@@ -146,10 +146,10 @@ pub trait Visitor<U = ()> {
             self.visit_expr(*value);
         }
     }
-    fn visit_stmt_For(&mut self, node: StmtFor) {
+    fn visit_stmt_For(&mut self, node: StmtFor<R>) {
         self.generic_visit_stmt_For(node)
     }
-    fn generic_visit_stmt_For(&mut self, node: StmtFor) {
+    fn generic_visit_stmt_For(&mut self, node: StmtFor<R>) {
         {
             let value = node.target;
             self.visit_expr(*value);
@@ -165,10 +165,10 @@ pub trait Visitor<U = ()> {
             self.visit_stmt(value);
         }
     }
-    fn visit_stmt_AsyncFor(&mut self, node: StmtAsyncFor) {
+    fn visit_stmt_AsyncFor(&mut self, node: StmtAsyncFor<R>) {
         self.generic_visit_stmt_AsyncFor(node)
     }
-    fn generic_visit_stmt_AsyncFor(&mut self, node: StmtAsyncFor) {
+    fn generic_visit_stmt_AsyncFor(&mut self, node: StmtAsyncFor<R>) {
         {
             let value = node.target;
             self.visit_expr(*value);
@@ -184,10 +184,10 @@ pub trait Visitor<U = ()> {
             self.visit_stmt(value);
         }
     }
-    fn visit_stmt_While(&mut self, node: StmtWhile) {
+    fn visit_stmt_While(&mut self, node: StmtWhile<R>) {
         self.generic_visit_stmt_While(node)
     }
-    fn generic_visit_stmt_While(&mut self, node: StmtWhile) {
+    fn generic_visit_stmt_While(&mut self, node: StmtWhile<R>) {
         {
             let value = node.test;
             self.visit_expr(*value);
@@ -199,10 +199,10 @@ pub trait Visitor<U = ()> {
             self.visit_stmt(value);
         }
     }
-    fn visit_stmt_If(&mut self, node: StmtIf) {
+    fn visit_stmt_If(&mut self, node: StmtIf<R>) {
         self.generic_visit_stmt_If(node)
     }
-    fn generic_visit_stmt_If(&mut self, node: StmtIf) {
+    fn generic_visit_stmt_If(&mut self, node: StmtIf<R>) {
         {
             let value = node.test;
             self.visit_expr(*value);
@@ -214,10 +214,10 @@ pub trait Visitor<U = ()> {
             self.visit_stmt(value);
         }
     }
-    fn visit_stmt_With(&mut self, node: StmtWith) {
+    fn visit_stmt_With(&mut self, node: StmtWith<R>) {
         self.generic_visit_stmt_With(node)
     }
-    fn generic_visit_stmt_With(&mut self, node: StmtWith) {
+    fn generic_visit_stmt_With(&mut self, node: StmtWith<R>) {
         for value in node.items {
             self.visit_withitem(value);
         }
@@ -225,10 +225,10 @@ pub trait Visitor<U = ()> {
             self.visit_stmt(value);
         }
     }
-    fn visit_stmt_AsyncWith(&mut self, node: StmtAsyncWith) {
+    fn visit_stmt_AsyncWith(&mut self, node: StmtAsyncWith<R>) {
         self.generic_visit_stmt_AsyncWith(node)
     }
-    fn generic_visit_stmt_AsyncWith(&mut self, node: StmtAsyncWith) {
+    fn generic_visit_stmt_AsyncWith(&mut self, node: StmtAsyncWith<R>) {
         for value in node.items {
             self.visit_withitem(value);
         }
@@ -236,10 +236,10 @@ pub trait Visitor<U = ()> {
             self.visit_stmt(value);
         }
     }
-    fn visit_stmt_Match(&mut self, node: StmtMatch) {
+    fn visit_stmt_Match(&mut self, node: StmtMatch<R>) {
         self.generic_visit_stmt_Match(node)
     }
-    fn generic_visit_stmt_Match(&mut self, node: StmtMatch) {
+    fn generic_visit_stmt_Match(&mut self, node: StmtMatch<R>) {
         {
             let value = node.subject;
             self.visit_expr(*value);
@@ -248,10 +248,10 @@ pub trait Visitor<U = ()> {
             self.visit_match_case(value);
         }
     }
-    fn visit_stmt_Raise(&mut self, node: StmtRaise) {
+    fn visit_stmt_Raise(&mut self, node: StmtRaise<R>) {
         self.generic_visit_stmt_Raise(node)
     }
-    fn generic_visit_stmt_Raise(&mut self, node: StmtRaise) {
+    fn generic_visit_stmt_Raise(&mut self, node: StmtRaise<R>) {
         if let Some(value) = node.exc {
             self.visit_expr(*value);
         }
@@ -259,10 +259,10 @@ pub trait Visitor<U = ()> {
             self.visit_expr(*value);
         }
     }
-    fn visit_stmt_Try(&mut self, node: StmtTry) {
+    fn visit_stmt_Try(&mut self, node: StmtTry<R>) {
         self.generic_visit_stmt_Try(node)
     }
-    fn generic_visit_stmt_Try(&mut self, node: StmtTry) {
+    fn generic_visit_stmt_Try(&mut self, node: StmtTry<R>) {
         for value in node.body {
             self.visit_stmt(value);
         }
@@ -276,10 +276,10 @@ pub trait Visitor<U = ()> {
             self.visit_stmt(value);
         }
     }
-    fn visit_stmt_TryStar(&mut self, node: StmtTryStar) {
+    fn visit_stmt_TryStar(&mut self, node: StmtTryStar<R>) {
         self.generic_visit_stmt_TryStar(node)
     }
-    fn generic_visit_stmt_TryStar(&mut self, node: StmtTryStar) {
+    fn generic_visit_stmt_TryStar(&mut self, node: StmtTryStar<R>) {
         for value in node.body {
             self.visit_stmt(value);
         }
@@ -293,10 +293,10 @@ pub trait Visitor<U = ()> {
             self.visit_stmt(value);
         }
     }
-    fn visit_stmt_Assert(&mut self, node: StmtAssert) {
+    fn visit_stmt_Assert(&mut self, node: StmtAssert<R>) {
         self.generic_visit_stmt_Assert(node)
     }
-    fn generic_visit_stmt_Assert(&mut self, node: StmtAssert) {
+    fn generic_visit_stmt_Assert(&mut self, node: StmtAssert<R>) {
         {
             let value = node.test;
             self.visit_expr(*value);
@@ -305,97 +305,88 @@ pub trait Visitor<U = ()> {
             self.visit_expr(*value);
         }
     }
-    fn visit_stmt_Import(&mut self, node: StmtImport) {
+    fn visit_stmt_Import(&mut self, node: StmtImport<R>) {
         self.generic_visit_stmt_Import(node)
     }
-    fn generic_visit_stmt_Import(&mut self, node: StmtImport) {
+    fn generic_visit_stmt_Import(&mut self, node: StmtImport<R>) {
         for value in node.names {
             self.visit_alias(value);
         }
     }
-    fn visit_stmt_ImportFrom(&mut self, node: StmtImportFrom) {
+    fn visit_stmt_ImportFrom(&mut self, node: StmtImportFrom<R>) {
         self.generic_visit_stmt_ImportFrom(node)
     }
-    fn generic_visit_stmt_ImportFrom(&mut self, node: StmtImportFrom) {
+    fn generic_visit_stmt_ImportFrom(&mut self, node: StmtImportFrom<R>) {
         for value in node.names {
             self.visit_alias(value);
         }
     }
-    fn visit_stmt_Global(&mut self, node: StmtGlobal) {
+    fn visit_stmt_Global(&mut self, node: StmtGlobal<R>) {
         self.generic_visit_stmt_Global(node)
     }
-    fn generic_visit_stmt_Global(&mut self, node: StmtGlobal) {}
-    fn visit_stmt_Nonlocal(&mut self, node: StmtNonlocal) {
+    fn generic_visit_stmt_Global(&mut self, node: StmtGlobal<R>) {}
+    fn visit_stmt_Nonlocal(&mut self, node: StmtNonlocal<R>) {
         self.generic_visit_stmt_Nonlocal(node)
     }
-    fn generic_visit_stmt_Nonlocal(&mut self, node: StmtNonlocal) {}
-    fn visit_stmt_Expr(&mut self, node: StmtExpr) {
+    fn generic_visit_stmt_Nonlocal(&mut self, node: StmtNonlocal<R>) {}
+    fn visit_stmt_Expr(&mut self, node: StmtExpr<R>) {
         self.generic_visit_stmt_Expr(node)
     }
-    fn generic_visit_stmt_Expr(&mut self, node: StmtExpr) {
+    fn generic_visit_stmt_Expr(&mut self, node: StmtExpr<R>) {
         {
             let value = node.value;
             self.visit_expr(*value);
         }
     }
-    fn visit_stmt_Pass(&mut self, node: ()) {
-        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_expr(&mut self, node: Expr) {
+    fn visit_stmt_Pass(&mut self, node: StmtPass<R>) {}
+    fn visit_stmt_Break(&mut self, node: StmtBreak<R>) {}
+    fn visit_stmt_Continue(&mut self, node: StmtContinue<R>) {}
+    fn visit_expr(&mut self, node: Expr<R>) {
         self.generic_visit_expr(node)
     }
-    fn generic_visit_expr(&mut self, node: Expr) {
-        match node.node {
-            ExprKind::BoolOp(data) => self.visit_expr_BoolOp(data),
-            ExprKind::NamedExpr(data) => self.visit_expr_NamedExpr(data),
-            ExprKind::BinOp(data) => self.visit_expr_BinOp(data),
-            ExprKind::UnaryOp(data) => self.visit_expr_UnaryOp(data),
-            ExprKind::Lambda(data) => self.visit_expr_Lambda(data),
-            ExprKind::IfExp(data) => self.visit_expr_IfExp(data),
-            ExprKind::Dict(data) => self.visit_expr_Dict(data),
-            ExprKind::Set(data) => self.visit_expr_Set(data),
-            ExprKind::ListComp(data) => self.visit_expr_ListComp(data),
-            ExprKind::SetComp(data) => self.visit_expr_SetComp(data),
-            ExprKind::DictComp(data) => self.visit_expr_DictComp(data),
-            ExprKind::GeneratorExp(data) => self.visit_expr_GeneratorExp(data),
-            ExprKind::Await(data) => self.visit_expr_Await(data),
-            ExprKind::Yield(data) => self.visit_expr_Yield(data),
-            ExprKind::YieldFrom(data) => self.visit_expr_YieldFrom(data),
-            ExprKind::Compare(data) => self.visit_expr_Compare(data),
-            ExprKind::Call(data) => self.visit_expr_Call(data),
-            ExprKind::FormattedValue(data) => self.visit_expr_FormattedValue(data),
-            ExprKind::JoinedStr(data) => self.visit_expr_JoinedStr(data),
-            ExprKind::Constant(data) => self.visit_expr_Constant(data),
-            ExprKind::Attribute(data) => self.visit_expr_Attribute(data),
-            ExprKind::Subscript(data) => self.visit_expr_Subscript(data),
-            ExprKind::Starred(data) => self.visit_expr_Starred(data),
-            ExprKind::Name(data) => self.visit_expr_Name(data),
-            ExprKind::List(data) => self.visit_expr_List(data),
-            ExprKind::Tuple(data) => self.visit_expr_Tuple(data),
-            ExprKind::Slice(data) => self.visit_expr_Slice(data),
+    fn generic_visit_expr(&mut self, node: Expr<R>) {
+        match node {
+            Expr::BoolOp(data) => self.visit_expr_BoolOp(data),
+            Expr::NamedExpr(data) => self.visit_expr_NamedExpr(data),
+            Expr::BinOp(data) => self.visit_expr_BinOp(data),
+            Expr::UnaryOp(data) => self.visit_expr_UnaryOp(data),
+            Expr::Lambda(data) => self.visit_expr_Lambda(data),
+            Expr::IfExp(data) => self.visit_expr_IfExp(data),
+            Expr::Dict(data) => self.visit_expr_Dict(data),
+            Expr::Set(data) => self.visit_expr_Set(data),
+            Expr::ListComp(data) => self.visit_expr_ListComp(data),
+            Expr::SetComp(data) => self.visit_expr_SetComp(data),
+            Expr::DictComp(data) => self.visit_expr_DictComp(data),
+            Expr::GeneratorExp(data) => self.visit_expr_GeneratorExp(data),
+            Expr::Await(data) => self.visit_expr_Await(data),
+            Expr::Yield(data) => self.visit_expr_Yield(data),
+            Expr::YieldFrom(data) => self.visit_expr_YieldFrom(data),
+            Expr::Compare(data) => self.visit_expr_Compare(data),
+            Expr::Call(data) => self.visit_expr_Call(data),
+            Expr::FormattedValue(data) => self.visit_expr_FormattedValue(data),
+            Expr::JoinedStr(data) => self.visit_expr_JoinedStr(data),
+            Expr::Constant(data) => self.visit_expr_Constant(data),
+            Expr::Attribute(data) => self.visit_expr_Attribute(data),
+            Expr::Subscript(data) => self.visit_expr_Subscript(data),
+            Expr::Starred(data) => self.visit_expr_Starred(data),
+            Expr::Name(data) => self.visit_expr_Name(data),
+            Expr::List(data) => self.visit_expr_List(data),
+            Expr::Tuple(data) => self.visit_expr_Tuple(data),
+            Expr::Slice(data) => self.visit_expr_Slice(data),
         }
     }
-    fn visit_expr_BoolOp(&mut self, node: ExprBoolOp) {
+    fn visit_expr_BoolOp(&mut self, node: ExprBoolOp<R>) {
         self.generic_visit_expr_BoolOp(node)
     }
-    fn generic_visit_expr_BoolOp(&mut self, node: ExprBoolOp) {
+    fn generic_visit_expr_BoolOp(&mut self, node: ExprBoolOp<R>) {
         for value in node.values {
             self.visit_expr(value);
         }
     }
-    fn visit_expr_NamedExpr(&mut self, node: ExprNamedExpr) {
+    fn visit_expr_NamedExpr(&mut self, node: ExprNamedExpr<R>) {
         self.generic_visit_expr_NamedExpr(node)
     }
-    fn generic_visit_expr_NamedExpr(&mut self, node: ExprNamedExpr) {
+    fn generic_visit_expr_NamedExpr(&mut self, node: ExprNamedExpr<R>) {
         {
             let value = node.target;
             self.visit_expr(*value);
@@ -405,10 +396,10 @@ pub trait Visitor<U = ()> {
             self.visit_expr(*value);
         }
     }
-    fn visit_expr_BinOp(&mut self, node: ExprBinOp) {
+    fn visit_expr_BinOp(&mut self, node: ExprBinOp<R>) {
         self.generic_visit_expr_BinOp(node)
     }
-    fn generic_visit_expr_BinOp(&mut self, node: ExprBinOp) {
+    fn generic_visit_expr_BinOp(&mut self, node: ExprBinOp<R>) {
         {
             let value = node.left;
             self.visit_expr(*value);
@@ -418,19 +409,19 @@ pub trait Visitor<U = ()> {
             self.visit_expr(*value);
         }
     }
-    fn visit_expr_UnaryOp(&mut self, node: ExprUnaryOp) {
+    fn visit_expr_UnaryOp(&mut self, node: ExprUnaryOp<R>) {
         self.generic_visit_expr_UnaryOp(node)
     }
-    fn generic_visit_expr_UnaryOp(&mut self, node: ExprUnaryOp) {
+    fn generic_visit_expr_UnaryOp(&mut self, node: ExprUnaryOp<R>) {
         {
             let value = node.operand;
             self.visit_expr(*value);
         }
     }
-    fn visit_expr_Lambda(&mut self, node: ExprLambda) {
+    fn visit_expr_Lambda(&mut self, node: ExprLambda<R>) {
         self.generic_visit_expr_Lambda(node)
     }
-    fn generic_visit_expr_Lambda(&mut self, node: ExprLambda) {
+    fn generic_visit_expr_Lambda(&mut self, node: ExprLambda<R>) {
         {
             let value = node.args;
             self.visit_arguments(*value);
@@ -440,10 +431,10 @@ pub trait Visitor<U = ()> {
             self.visit_expr(*value);
         }
     }
-    fn visit_expr_IfExp(&mut self, node: ExprIfExp) {
+    fn visit_expr_IfExp(&mut self, node: ExprIfExp<R>) {
         self.generic_visit_expr_IfExp(node)
     }
-    fn generic_visit_expr_IfExp(&mut self, node: ExprIfExp) {
+    fn generic_visit_expr_IfExp(&mut self, node: ExprIfExp<R>) {
         {
             let value = node.test;
             self.visit_expr(*value);
@@ -457,10 +448,10 @@ pub trait Visitor<U = ()> {
             self.visit_expr(*value);
         }
     }
-    fn visit_expr_Dict(&mut self, node: ExprDict) {
+    fn visit_expr_Dict(&mut self, node: ExprDict<R>) {
         self.generic_visit_expr_Dict(node)
     }
-    fn generic_visit_expr_Dict(&mut self, node: ExprDict) {
+    fn generic_visit_expr_Dict(&mut self, node: ExprDict<R>) {
         for value in node.keys.into_iter().flatten() {
             self.visit_expr(value);
         }
@@ -468,18 +459,18 @@ pub trait Visitor<U = ()> {
             self.visit_expr(value);
         }
     }
-    fn visit_expr_Set(&mut self, node: ExprSet) {
+    fn visit_expr_Set(&mut self, node: ExprSet<R>) {
         self.generic_visit_expr_Set(node)
     }
-    fn generic_visit_expr_Set(&mut self, node: ExprSet) {
+    fn generic_visit_expr_Set(&mut self, node: ExprSet<R>) {
         for value in node.elts {
             self.visit_expr(value);
         }
     }
-    fn visit_expr_ListComp(&mut self, node: ExprListComp) {
+    fn visit_expr_ListComp(&mut self, node: ExprListComp<R>) {
         self.generic_visit_expr_ListComp(node)
     }
-    fn generic_visit_expr_ListComp(&mut self, node: ExprListComp) {
+    fn generic_visit_expr_ListComp(&mut self, node: ExprListComp<R>) {
         {
             let value = node.elt;
             self.visit_expr(*value);
@@ -488,10 +479,10 @@ pub trait Visitor<U = ()> {
             self.visit_comprehension(value);
         }
     }
-    fn visit_expr_SetComp(&mut self, node: ExprSetComp) {
+    fn visit_expr_SetComp(&mut self, node: ExprSetComp<R>) {
         self.generic_visit_expr_SetComp(node)
     }
-    fn generic_visit_expr_SetComp(&mut self, node: ExprSetComp) {
+    fn generic_visit_expr_SetComp(&mut self, node: ExprSetComp<R>) {
         {
             let value = node.elt;
             self.visit_expr(*value);
@@ -500,10 +491,10 @@ pub trait Visitor<U = ()> {
             self.visit_comprehension(value);
         }
     }
-    fn visit_expr_DictComp(&mut self, node: ExprDictComp) {
+    fn visit_expr_DictComp(&mut self, node: ExprDictComp<R>) {
         self.generic_visit_expr_DictComp(node)
     }
-    fn generic_visit_expr_DictComp(&mut self, node: ExprDictComp) {
+    fn generic_visit_expr_DictComp(&mut self, node: ExprDictComp<R>) {
         {
             let value = node.key;
             self.visit_expr(*value);
@@ -516,10 +507,10 @@ pub trait Visitor<U = ()> {
             self.visit_comprehension(value);
         }
     }
-    fn visit_expr_GeneratorExp(&mut self, node: ExprGeneratorExp) {
+    fn visit_expr_GeneratorExp(&mut self, node: ExprGeneratorExp<R>) {
         self.generic_visit_expr_GeneratorExp(node)
     }
-    fn generic_visit_expr_GeneratorExp(&mut self, node: ExprGeneratorExp) {
+    fn generic_visit_expr_GeneratorExp(&mut self, node: ExprGeneratorExp<R>) {
         {
             let value = node.elt;
             self.visit_expr(*value);
@@ -528,36 +519,36 @@ pub trait Visitor<U = ()> {
             self.visit_comprehension(value);
         }
     }
-    fn visit_expr_Await(&mut self, node: ExprAwait) {
+    fn visit_expr_Await(&mut self, node: ExprAwait<R>) {
         self.generic_visit_expr_Await(node)
     }
-    fn generic_visit_expr_Await(&mut self, node: ExprAwait) {
+    fn generic_visit_expr_Await(&mut self, node: ExprAwait<R>) {
         {
             let value = node.value;
             self.visit_expr(*value);
         }
     }
-    fn visit_expr_Yield(&mut self, node: ExprYield) {
+    fn visit_expr_Yield(&mut self, node: ExprYield<R>) {
         self.generic_visit_expr_Yield(node)
     }
-    fn generic_visit_expr_Yield(&mut self, node: ExprYield) {
+    fn generic_visit_expr_Yield(&mut self, node: ExprYield<R>) {
         if let Some(value) = node.value {
             self.visit_expr(*value);
         }
     }
-    fn visit_expr_YieldFrom(&mut self, node: ExprYieldFrom) {
+    fn visit_expr_YieldFrom(&mut self, node: ExprYieldFrom<R>) {
         self.generic_visit_expr_YieldFrom(node)
     }
-    fn generic_visit_expr_YieldFrom(&mut self, node: ExprYieldFrom) {
+    fn generic_visit_expr_YieldFrom(&mut self, node: ExprYieldFrom<R>) {
         {
             let value = node.value;
             self.visit_expr(*value);
         }
     }
-    fn visit_expr_Compare(&mut self, node: ExprCompare) {
+    fn visit_expr_Compare(&mut self, node: ExprCompare<R>) {
         self.generic_visit_expr_Compare(node)
     }
-    fn generic_visit_expr_Compare(&mut self, node: ExprCompare) {
+    fn generic_visit_expr_Compare(&mut self, node: ExprCompare<R>) {
         {
             let value = node.left;
             self.visit_expr(*value);
@@ -566,10 +557,10 @@ pub trait Visitor<U = ()> {
             self.visit_expr(value);
         }
     }
-    fn visit_expr_Call(&mut self, node: ExprCall) {
+    fn visit_expr_Call(&mut self, node: ExprCall<R>) {
         self.generic_visit_expr_Call(node)
     }
-    fn generic_visit_expr_Call(&mut self, node: ExprCall) {
+    fn generic_visit_expr_Call(&mut self, node: ExprCall<R>) {
         {
             let value = node.func;
             self.visit_expr(*value);
@@ -581,10 +572,10 @@ pub trait Visitor<U = ()> {
             self.visit_keyword(value);
         }
     }
-    fn visit_expr_FormattedValue(&mut self, node: ExprFormattedValue) {
+    fn visit_expr_FormattedValue(&mut self, node: ExprFormattedValue<R>) {
         self.generic_visit_expr_FormattedValue(node)
     }
-    fn generic_visit_expr_FormattedValue(&mut self, node: ExprFormattedValue) {
+    fn generic_visit_expr_FormattedValue(&mut self, node: ExprFormattedValue<R>) {
         {
             let value = node.value;
             self.visit_expr(*value);
@@ -593,31 +584,31 @@ pub trait Visitor<U = ()> {
             self.visit_expr(*value);
         }
     }
-    fn visit_expr_JoinedStr(&mut self, node: ExprJoinedStr) {
+    fn visit_expr_JoinedStr(&mut self, node: ExprJoinedStr<R>) {
         self.generic_visit_expr_JoinedStr(node)
     }
-    fn generic_visit_expr_JoinedStr(&mut self, node: ExprJoinedStr) {
+    fn generic_visit_expr_JoinedStr(&mut self, node: ExprJoinedStr<R>) {
         for value in node.values {
             self.visit_expr(value);
         }
     }
-    fn visit_expr_Constant(&mut self, node: ExprConstant) {
+    fn visit_expr_Constant(&mut self, node: ExprConstant<R>) {
         self.generic_visit_expr_Constant(node)
     }
-    fn generic_visit_expr_Constant(&mut self, node: ExprConstant) {}
-    fn visit_expr_Attribute(&mut self, node: ExprAttribute) {
+    fn generic_visit_expr_Constant(&mut self, node: ExprConstant<R>) {}
+    fn visit_expr_Attribute(&mut self, node: ExprAttribute<R>) {
         self.generic_visit_expr_Attribute(node)
     }
-    fn generic_visit_expr_Attribute(&mut self, node: ExprAttribute) {
+    fn generic_visit_expr_Attribute(&mut self, node: ExprAttribute<R>) {
         {
             let value = node.value;
             self.visit_expr(*value);
         }
     }
-    fn visit_expr_Subscript(&mut self, node: ExprSubscript) {
+    fn visit_expr_Subscript(&mut self, node: ExprSubscript<R>) {
         self.generic_visit_expr_Subscript(node)
     }
-    fn generic_visit_expr_Subscript(&mut self, node: ExprSubscript) {
+    fn generic_visit_expr_Subscript(&mut self, node: ExprSubscript<R>) {
         {
             let value = node.value;
             self.visit_expr(*value);
@@ -627,39 +618,39 @@ pub trait Visitor<U = ()> {
             self.visit_expr(*value);
         }
     }
-    fn visit_expr_Starred(&mut self, node: ExprStarred) {
+    fn visit_expr_Starred(&mut self, node: ExprStarred<R>) {
         self.generic_visit_expr_Starred(node)
     }
-    fn generic_visit_expr_Starred(&mut self, node: ExprStarred) {
+    fn generic_visit_expr_Starred(&mut self, node: ExprStarred<R>) {
         {
             let value = node.value;
             self.visit_expr(*value);
         }
     }
-    fn visit_expr_Name(&mut self, node: ExprName) {
+    fn visit_expr_Name(&mut self, node: ExprName<R>) {
         self.generic_visit_expr_Name(node)
     }
-    fn generic_visit_expr_Name(&mut self, node: ExprName) {}
-    fn visit_expr_List(&mut self, node: ExprList) {
+    fn generic_visit_expr_Name(&mut self, node: ExprName<R>) {}
+    fn visit_expr_List(&mut self, node: ExprList<R>) {
         self.generic_visit_expr_List(node)
     }
-    fn generic_visit_expr_List(&mut self, node: ExprList) {
+    fn generic_visit_expr_List(&mut self, node: ExprList<R>) {
         for value in node.elts {
             self.visit_expr(value);
         }
     }
-    fn visit_expr_Tuple(&mut self, node: ExprTuple) {
+    fn visit_expr_Tuple(&mut self, node: ExprTuple<R>) {
         self.generic_visit_expr_Tuple(node)
     }
-    fn generic_visit_expr_Tuple(&mut self, node: ExprTuple) {
+    fn generic_visit_expr_Tuple(&mut self, node: ExprTuple<R>) {
         for value in node.elts {
             self.visit_expr(value);
         }
     }
-    fn visit_expr_Slice(&mut self, node: ExprSlice) {
+    fn visit_expr_Slice(&mut self, node: ExprSlice<R>) {
         self.generic_visit_expr_Slice(node)
     }
-    fn generic_visit_expr_Slice(&mut self, node: ExprSlice) {
+    fn generic_visit_expr_Slice(&mut self, node: ExprSlice<R>) {
         if let Some(value) = node.lower {
             self.visit_expr(*value);
         }
@@ -690,22 +681,22 @@ pub trait Visitor<U = ()> {
         self.generic_visit_cmpop(node)
     }
     fn generic_visit_cmpop(&mut self, node: Cmpop) {}
-    fn visit_comprehension(&mut self, node: Comprehension) {
+    fn visit_comprehension(&mut self, node: Comprehension<R>) {
         self.generic_visit_comprehension(node)
     }
-    fn generic_visit_comprehension(&mut self, node: Comprehension) {}
-    fn visit_excepthandler(&mut self, node: Excepthandler) {
+    fn generic_visit_comprehension(&mut self, node: Comprehension<R>) {}
+    fn visit_excepthandler(&mut self, node: Excepthandler<R>) {
         self.generic_visit_excepthandler(node)
     }
-    fn generic_visit_excepthandler(&mut self, node: Excepthandler) {
-        match node.node {
-            ExcepthandlerKind::ExceptHandler(data) => self.visit_excepthandler_ExceptHandler(data),
+    fn generic_visit_excepthandler(&mut self, node: Excepthandler<R>) {
+        match node {
+            Excepthandler::ExceptHandler(data) => self.visit_excepthandler_ExceptHandler(data),
         }
     }
-    fn visit_excepthandler_ExceptHandler(&mut self, node: ExcepthandlerExceptHandler) {
+    fn visit_excepthandler_ExceptHandler(&mut self, node: ExcepthandlerExceptHandler<R>) {
         self.generic_visit_excepthandler_ExceptHandler(node)
     }
-    fn generic_visit_excepthandler_ExceptHandler(&mut self, node: ExcepthandlerExceptHandler) {
+    fn generic_visit_excepthandler_ExceptHandler(&mut self, node: ExcepthandlerExceptHandler<R>) {
         if let Some(value) = node.type_ {
             self.visit_expr(*value);
         }
@@ -713,70 +704,70 @@ pub trait Visitor<U = ()> {
             self.visit_stmt(value);
         }
     }
-    fn visit_arguments(&mut self, node: Arguments) {
+    fn visit_arguments(&mut self, node: Arguments<R>) {
         self.generic_visit_arguments(node)
     }
-    fn generic_visit_arguments(&mut self, node: Arguments) {}
-    fn visit_arg(&mut self, node: Arg) {
+    fn generic_visit_arguments(&mut self, node: Arguments<R>) {}
+    fn visit_arg(&mut self, node: Arg<R>) {
         self.generic_visit_arg(node)
     }
-    fn generic_visit_arg(&mut self, node: Arg) {}
-    fn visit_keyword(&mut self, node: Keyword) {
+    fn generic_visit_arg(&mut self, node: Arg<R>) {}
+    fn visit_keyword(&mut self, node: Keyword<R>) {
         self.generic_visit_keyword(node)
     }
-    fn generic_visit_keyword(&mut self, node: Keyword) {}
-    fn visit_alias(&mut self, node: Alias) {
+    fn generic_visit_keyword(&mut self, node: Keyword<R>) {}
+    fn visit_alias(&mut self, node: Alias<R>) {
         self.generic_visit_alias(node)
     }
-    fn generic_visit_alias(&mut self, node: Alias) {}
-    fn visit_withitem(&mut self, node: Withitem) {
+    fn generic_visit_alias(&mut self, node: Alias<R>) {}
+    fn visit_withitem(&mut self, node: Withitem<R>) {
         self.generic_visit_withitem(node)
     }
-    fn generic_visit_withitem(&mut self, node: Withitem) {}
-    fn visit_match_case(&mut self, node: MatchCase) {
+    fn generic_visit_withitem(&mut self, node: Withitem<R>) {}
+    fn visit_match_case(&mut self, node: MatchCase<R>) {
         self.generic_visit_match_case(node)
     }
-    fn generic_visit_match_case(&mut self, node: MatchCase) {}
-    fn visit_pattern(&mut self, node: Pattern) {
+    fn generic_visit_match_case(&mut self, node: MatchCase<R>) {}
+    fn visit_pattern(&mut self, node: Pattern<R>) {
         self.generic_visit_pattern(node)
     }
-    fn generic_visit_pattern(&mut self, node: Pattern) {
-        match node.node {
-            PatternKind::MatchValue(data) => self.visit_pattern_MatchValue(data),
-            PatternKind::MatchSingleton(data) => self.visit_pattern_MatchSingleton(data),
-            PatternKind::MatchSequence(data) => self.visit_pattern_MatchSequence(data),
-            PatternKind::MatchMapping(data) => self.visit_pattern_MatchMapping(data),
-            PatternKind::MatchClass(data) => self.visit_pattern_MatchClass(data),
-            PatternKind::MatchStar(data) => self.visit_pattern_MatchStar(data),
-            PatternKind::MatchAs(data) => self.visit_pattern_MatchAs(data),
-            PatternKind::MatchOr(data) => self.visit_pattern_MatchOr(data),
+    fn generic_visit_pattern(&mut self, node: Pattern<R>) {
+        match node {
+            Pattern::MatchValue(data) => self.visit_pattern_MatchValue(data),
+            Pattern::MatchSingleton(data) => self.visit_pattern_MatchSingleton(data),
+            Pattern::MatchSequence(data) => self.visit_pattern_MatchSequence(data),
+            Pattern::MatchMapping(data) => self.visit_pattern_MatchMapping(data),
+            Pattern::MatchClass(data) => self.visit_pattern_MatchClass(data),
+            Pattern::MatchStar(data) => self.visit_pattern_MatchStar(data),
+            Pattern::MatchAs(data) => self.visit_pattern_MatchAs(data),
+            Pattern::MatchOr(data) => self.visit_pattern_MatchOr(data),
         }
     }
-    fn visit_pattern_MatchValue(&mut self, node: PatternMatchValue) {
+    fn visit_pattern_MatchValue(&mut self, node: PatternMatchValue<R>) {
         self.generic_visit_pattern_MatchValue(node)
     }
-    fn generic_visit_pattern_MatchValue(&mut self, node: PatternMatchValue) {
+    fn generic_visit_pattern_MatchValue(&mut self, node: PatternMatchValue<R>) {
         {
             let value = node.value;
             self.visit_expr(*value);
         }
     }
-    fn visit_pattern_MatchSingleton(&mut self, node: PatternMatchSingleton) {
+    fn visit_pattern_MatchSingleton(&mut self, node: PatternMatchSingleton<R>) {
         self.generic_visit_pattern_MatchSingleton(node)
     }
-    fn generic_visit_pattern_MatchSingleton(&mut self, node: PatternMatchSingleton) {}
-    fn visit_pattern_MatchSequence(&mut self, node: PatternMatchSequence) {
+    fn generic_visit_pattern_MatchSingleton(&mut self, node: PatternMatchSingleton<R>) {}
+    fn visit_pattern_MatchSequence(&mut self, node: PatternMatchSequence<R>) {
         self.generic_visit_pattern_MatchSequence(node)
     }
-    fn generic_visit_pattern_MatchSequence(&mut self, node: PatternMatchSequence) {
+    fn generic_visit_pattern_MatchSequence(&mut self, node: PatternMatchSequence<R>) {
         for value in node.patterns {
             self.visit_pattern(value);
         }
     }
-    fn visit_pattern_MatchMapping(&mut self, node: PatternMatchMapping) {
+    fn visit_pattern_MatchMapping(&mut self, node: PatternMatchMapping<R>) {
         self.generic_visit_pattern_MatchMapping(node)
     }
-    fn generic_visit_pattern_MatchMapping(&mut self, node: PatternMatchMapping) {
+    fn generic_visit_pattern_MatchMapping(&mut self, node: PatternMatchMapping<R>) {
         for value in node.keys {
             self.visit_expr(value);
         }
@@ -784,10 +775,10 @@ pub trait Visitor<U = ()> {
             self.visit_pattern(value);
         }
     }
-    fn visit_pattern_MatchClass(&mut self, node: PatternMatchClass) {
+    fn visit_pattern_MatchClass(&mut self, node: PatternMatchClass<R>) {
         self.generic_visit_pattern_MatchClass(node)
     }
-    fn generic_visit_pattern_MatchClass(&mut self, node: PatternMatchClass) {
+    fn generic_visit_pattern_MatchClass(&mut self, node: PatternMatchClass<R>) {
         {
             let value = node.cls;
             self.visit_expr(*value);
@@ -799,22 +790,22 @@ pub trait Visitor<U = ()> {
             self.visit_pattern(value);
         }
     }
-    fn visit_pattern_MatchStar(&mut self, node: PatternMatchStar) {
+    fn visit_pattern_MatchStar(&mut self, node: PatternMatchStar<R>) {
         self.generic_visit_pattern_MatchStar(node)
     }
-    fn generic_visit_pattern_MatchStar(&mut self, node: PatternMatchStar) {}
-    fn visit_pattern_MatchAs(&mut self, node: PatternMatchAs) {
+    fn generic_visit_pattern_MatchStar(&mut self, node: PatternMatchStar<R>) {}
+    fn visit_pattern_MatchAs(&mut self, node: PatternMatchAs<R>) {
         self.generic_visit_pattern_MatchAs(node)
     }
-    fn generic_visit_pattern_MatchAs(&mut self, node: PatternMatchAs) {
+    fn generic_visit_pattern_MatchAs(&mut self, node: PatternMatchAs<R>) {
         if let Some(value) = node.pattern {
             self.visit_pattern(*value);
         }
     }
-    fn visit_pattern_MatchOr(&mut self, node: PatternMatchOr) {
+    fn visit_pattern_MatchOr(&mut self, node: PatternMatchOr<R>) {
         self.generic_visit_pattern_MatchOr(node)
     }
-    fn generic_visit_pattern_MatchOr(&mut self, node: PatternMatchOr) {
+    fn generic_visit_pattern_MatchOr(&mut self, node: PatternMatchOr<R>) {
         for value in node.patterns {
             self.visit_pattern(value);
         }

ast/src/impls.rs

@@ -1,19 +1,17 @@
-use crate::{Constant, ExprKind};
+use crate::{Constant, Excepthandler, Expr, Pattern, Stmt};
 
-impl<U> ExprKind<U> {
+impl<R> Expr<R> {
     /// Returns a short name for the node suitable for use in error messages.
     pub fn python_name(&self) -> &'static str {
         match self {
-            ExprKind::BoolOp { .. } | ExprKind::BinOp { .. } | ExprKind::UnaryOp { .. } => {
-                "operator"
-            }
-            ExprKind::Subscript { .. } => "subscript",
-            ExprKind::Await { .. } => "await expression",
-            ExprKind::Yield { .. } | ExprKind::YieldFrom { .. } => "yield expression",
-            ExprKind::Compare { .. } => "comparison",
-            ExprKind::Attribute { .. } => "attribute",
-            ExprKind::Call { .. } => "function call",
-            ExprKind::Constant(crate::ExprConstant { value, .. }) => match value {
+            Expr::BoolOp { .. } | Expr::BinOp { .. } | Expr::UnaryOp { .. } => "operator",
+            Expr::Subscript { .. } => "subscript",
+            Expr::Await { .. } => "await expression",
+            Expr::Yield { .. } | Expr::YieldFrom { .. } => "yield expression",
+            Expr::Compare { .. } => "comparison",
+            Expr::Attribute { .. } => "attribute",
+            Expr::Call { .. } => "function call",
+            Expr::Constant(crate::ExprConstant { value, .. }) => match value {
                 Constant::Str(_)
                 | Constant::Int(_)
                 | Constant::Float(_)
@@ -30,31 +28,37 @@ impl<U> ExprKind<U> {
                 Constant::None => "None",
                 Constant::Ellipsis => "ellipsis",
             },
-            ExprKind::List { .. } => "list",
-            ExprKind::Tuple { .. } => "tuple",
-            ExprKind::Dict { .. } => "dict display",
-            ExprKind::Set { .. } => "set display",
-            ExprKind::ListComp { .. } => "list comprehension",
-            ExprKind::DictComp { .. } => "dict comprehension",
-            ExprKind::SetComp { .. } => "set comprehension",
-            ExprKind::GeneratorExp { .. } => "generator expression",
-            ExprKind::Starred { .. } => "starred",
-            ExprKind::Slice { .. } => "slice",
-            ExprKind::JoinedStr(crate::ExprJoinedStr { values }) => {
-                if values
-                    .iter()
-                    .any(|e| matches!(e.node, ExprKind::JoinedStr { .. }))
-                {
+            Expr::List { .. } => "list",
+            Expr::Tuple { .. } => "tuple",
+            Expr::Dict { .. } => "dict display",
+            Expr::Set { .. } => "set display",
+            Expr::ListComp { .. } => "list comprehension",
+            Expr::DictComp { .. } => "dict comprehension",
+            Expr::SetComp { .. } => "set comprehension",
+            Expr::GeneratorExp { .. } => "generator expression",
+            Expr::Starred { .. } => "starred",
+            Expr::Slice { .. } => "slice",
+            Expr::JoinedStr(crate::ExprJoinedStr { values, .. }) => {
+                if values.iter().any(|e| e.is_joined_str_expr()) {
                     "f-string expression"
                 } else {
                     "literal"
                 }
             }
-            ExprKind::FormattedValue { .. } => "f-string expression",
-            ExprKind::Name { .. } => "name",
-            ExprKind::Lambda { .. } => "lambda",
-            ExprKind::IfExp { .. } => "conditional expression",
-            ExprKind::NamedExpr { .. } => "named expression",
+            Expr::FormattedValue { .. } => "f-string expression",
+            Expr::Name { .. } => "name",
+            Expr::Lambda { .. } => "lambda",
+            Expr::IfExp { .. } => "conditional expression",
+            Expr::NamedExpr { .. } => "named expression",
         }
     }
 }
+
+#[cfg(target_arch = "x86_64")]
+static_assertions::assert_eq_size!(Expr, [u8; 72]);
+#[cfg(target_arch = "x86_64")]
+static_assertions::assert_eq_size!(Stmt, [u8; 136]);
+#[cfg(target_arch = "x86_64")]
+static_assertions::assert_eq_size!(Pattern, [u8; 96]);
+#[cfg(target_arch = "x86_64")]
+static_assertions::assert_eq_size!(Excepthandler, [u8; 64]);

ast/src/lib.rs

@@ -8,6 +8,7 @@ mod generic {
     include!("gen/generic.rs");
 }
 mod impls;
+mod ranged;
 #[cfg(feature = "location")]
 mod source_locator;
 #[cfg(feature = "unparse")]
@@ -15,13 +16,13 @@ mod unparse;
 
 pub use builtin::*;
 pub use generic::*;
+pub use ranged::{EmptyRange, OptionalRange, Ranged, Suite};
 pub use rustpython_parser_core::{text_size, ConversionFlag};
 
-pub type Suite<U = ()> = Vec<Stmt<U>>;
-
 #[cfg(feature = "fold")]
 pub mod fold {
     use super::generic::*;
+
     include!("gen/fold.rs");
 }
 
@@ -33,9 +34,7 @@ mod visitor {
 }
 
 #[cfg(feature = "location")]
-pub mod located {
-    include!("gen/located.rs");
-}
+pub mod located;
 
 #[cfg(feature = "location")]
 pub use rustpython_parser_core::source_code;

ast/src/located.rs

@@ -0,0 +1,19 @@
+#![allow(clippy::derive_partial_eq_without_eq)]
+use crate::source_code::{SourceLocation, SourceRange};
+
+pub trait Located {
+    fn range(&self) -> SourceRange;
+
+    fn location(&self) -> SourceLocation {
+        self.range().start
+    }
+
+    fn end_location(&self) -> Option<SourceLocation> {
+        self.range().end
+    }
+}
+
+pub type Suite = Vec<Stmt>;
+
+pub use crate::builtin::*;
+include!("gen/located.rs");

ast/src/optimizer.rs

@@ -20,35 +20,29 @@ 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 {
-            crate::ExprKind::Tuple(crate::ExprTuple { elts, ctx }) => {
+        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::ExprKind::Constant { .. }))
-                {
+                let expr = if elts.iter().all(|e| e.is_constant_expr()) {
                     let tuple = elts
                         .into_iter()
-                        .map(|e| match e.node {
-                            crate::ExprKind::Constant(crate::ExprConstant { value, .. }) => value,
+                        .map(|e| match e {
+                            crate::Expr::Constant(crate::ExprConstant { value, .. }) => value,
                             _ => unreachable!(),
                         })
                         .collect();
-                    crate::ExprKind::Constant(crate::ExprConstant {
+                    crate::Expr::Constant(crate::ExprConstant {
                         value: Constant::Tuple(tuple),
                         kind: None,
+                        range,
                     })
                 } else {
-                    crate::ExprKind::Tuple(crate::ExprTuple { elts, ctx })
+                    crate::Expr::Tuple(crate::ExprTuple { elts, ctx, range })
                 };
-                Ok(crate::Expr {
-                    node: expr,
-                    custom: node.custom,
-                    range: node.range,
-                })
+                Ok(expr)
             }
             _ => crate::fold::fold_expr(self, node),
         }
@@ -66,95 +60,68 @@ mod tests {
         use crate::{fold::Fold, *};
 
         let range = TextRange::default();
-        #[allow(clippy::let_unit_value)]
-        let custom = ();
-        let ast = Attributed {
+        let ast = ExprTuple {
+            ctx: ExprContext::Load,
+            elts: vec![
+                ExprConstant {
+                    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![
+                        ExprConstant {
+                            value: BigInt::from(3).into(),
+                            kind: None,
+                            range,
+                        }
+                        .into(),
+                        ExprConstant {
+                            value: BigInt::from(4).into(),
+                            kind: None,
+                            range,
+                        }
+                        .into(),
+                        ExprConstant {
+                            value: BigInt::from(5).into(),
+                            kind: None,
+                            range,
+                        }
+                        .into(),
+                    ],
+                    range,
+                }
+                .into(),
+            ],
             range,
-            custom,
-            node: ExprTuple {
-                ctx: ExprContext::Load,
-                elts: vec![
-                    Attributed {
-                        range,
-                        custom,
-                        node: ExprConstant {
-                            value: BigInt::from(1).into(),
-                            kind: None,
-                        }
-                        .into(),
-                    },
-                    Attributed {
-                        range,
-                        custom,
-                        node: ExprConstant {
-                            value: BigInt::from(2).into(),
-                            kind: None,
-                        }
-                        .into(),
-                    },
-                    Attributed {
-                        range,
-                        custom,
-                        node: ExprTuple {
-                            ctx: ExprContext::Load,
-                            elts: vec![
-                                Attributed {
-                                    range,
-                                    custom,
-                                    node: ExprConstant {
-                                        value: BigInt::from(3).into(),
-                                        kind: None,
-                                    }
-                                    .into(),
-                                },
-                                Attributed {
-                                    range,
-                                    custom,
-                                    node: ExprConstant {
-                                        value: BigInt::from(4).into(),
-                                        kind: None,
-                                    }
-                                    .into(),
-                                },
-                                Attributed {
-                                    range,
-                                    custom,
-                                    node: ExprConstant {
-                                        value: BigInt::from(5).into(),
-                                        kind: None,
-                                    }
-                                    .into(),
-                                },
-                            ],
-                        }
-                        .into(),
-                    },
-                ],
-            }
-            .into(),
         };
         let new_ast = ConstantOptimizer::new()
-            .fold_expr(ast)
+            .fold_expr(ast.into())
             .unwrap_or_else(|e| match e {});
         assert_eq!(
             new_ast,
-            Attributed {
+            ExprConstant {
+                value: Constant::Tuple(vec![
+                    BigInt::from(1).into(),
+                    BigInt::from(2).into(),
+                    Constant::Tuple(vec![
+                        BigInt::from(3).into(),
+                        BigInt::from(4).into(),
+                        BigInt::from(5).into(),
+                    ])
+                ]),
+                kind: None,
                 range,
-                custom,
-                node: ExprConstant {
-                    value: Constant::Tuple(vec![
-                        BigInt::from(1).into(),
-                        BigInt::from(2).into(),
-                        Constant::Tuple(vec![
-                            BigInt::from(3).into(),
-                            BigInt::from(4).into(),
-                            BigInt::from(5).into(),
-                        ])
-                    ]),
-                    kind: None
-                }
-                .into(),
             }
+            .into(),
         );
     }
 }

ast/src/ranged.rs

@@ -0,0 +1,62 @@
+use crate::text_size::{TextRange, TextSize};
+use std::fmt::{Debug, Display, Formatter};
+use std::marker::PhantomData;
+
+pub use crate::builtin::*;
+use crate::Stmt;
+
+pub trait Ranged {
+    fn range(&self) -> TextRange;
+
+    fn start(&self) -> TextSize {
+        self.range().start()
+    }
+
+    fn end(&self) -> TextSize {
+        self.range().end()
+    }
+}
+
+pub type Suite<R = TextRange> = Vec<Stmt<R>>;
+
+#[cfg(feature = "all-nodes-with-ranges")]
+pub type OptionalRange<R> = R;
+
+#[cfg(not(feature = "all-nodes-with-ranges"))]
+pub type OptionalRange<R> = EmptyRange<R>;
+
+#[derive(Eq, PartialEq, Hash, Copy, Clone)]
+pub struct EmptyRange<R> {
+    phantom: PhantomData<R>,
+}
+
+impl<R> EmptyRange<R> {
+    #[inline(always)]
+    pub fn new(_start: TextSize, _end: TextSize) -> Self {
+        Self {
+            phantom: PhantomData,
+        }
+    }
+}
+
+impl<R> Display for EmptyRange<R> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.write_str("()")
+    }
+}
+
+impl<R> Debug for EmptyRange<R> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        Display::fmt(self, f)
+    }
+}
+
+impl<R> Default for EmptyRange<R> {
+    fn default() -> Self {
+        EmptyRange {
+            phantom: PhantomData,
+        }
+    }
+}
+
+include!("gen/ranged.rs");

ast/src/source_locator.rs

@@ -1,39 +1,15 @@
-use crate::builtin::Attributed;
-use rustpython_parser_core::source_code::{SourceLocation, SourceLocator, SourceRange};
+use rustpython_parser_core::{
+    source_code::{SourceLocator, SourceRange},
+    text_size::TextRange,
+};
 
-impl crate::fold::Fold<()> for SourceLocator<'_> {
+impl crate::fold::Fold<TextRange> for SourceLocator<'_> {
     type TargetU = SourceRange;
     type Error = std::convert::Infallible;
 
-    #[cold]
-    fn map_user(&mut self, _user: ()) -> Result<Self::TargetU, Self::Error> {
-        unreachable!("implemented map_attributed");
-    }
-
-    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());
-        Ok(Attributed {
-            range: node.range,
-            custom: (start..end).into(),
-            node: node.node,
-        })
-    }
-}
-
-impl<T> Attributed<T, SourceRange> {
-    /// Returns the absolute start position of the node from the beginning of the document.
-    #[inline]
-    pub const fn location(&self) -> SourceLocation {
-        self.custom.start
-    }
-
-    /// Returns the absolute position at which the node ends in the source document.
-    #[inline]
-    pub const fn end_location(&self) -> Option<SourceLocation> {
-        self.custom.end
+    fn map_user(&mut self, user: TextRange) -> Result<Self::TargetU, Self::Error> {
+        let start = self.locate(user.start());
+        let end = self.locate(user.end());
+        Ok((start..end).into())
     }
 }

ast/src/unparse.rs

@@ -1,7 +1,5 @@
 use crate::ConversionFlag;
-use crate::{
-    Arg, Arguments, Boolop, Cmpop, Comprehension, Constant, Expr, ExprKind, Identifier, Operator,
-};
+use crate::{Arg, Arguments, Boolop, Cmpop, Comprehension, Constant, Expr, Identifier, Operator};
 use std::fmt;
 
 mod precedence {
@@ -73,8 +71,12 @@ impl<'a> Unparser<'a> {
                 ret
             }};
         }
-        match &ast.node {
-            ExprKind::BoolOp(crate::ExprBoolOp { op, values }) => {
+        match &ast {
+            Expr::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 +86,23 @@ impl<'a> Unparser<'a> {
                     }
                 })
             }
-            ExprKind::NamedExpr(crate::ExprNamedExpr { target, value }) => {
+            Expr::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 }) => {
+            Expr::BinOp(crate::ExprBinOp {
+                left,
+                op,
+                right,
+                range: _range,
+            }) => {
                 let right_associative = matches!(op, Operator::Pow);
                 let (op, prec) = op_prec!(
                     bin,
@@ -117,7 +128,11 @@ impl<'a> Unparser<'a> {
                     self.unparse_expr(right, prec + !right_associative as u8)?;
                 })
             }
-            ExprKind::UnaryOp(crate::ExprUnaryOp { op, operand }) => {
+            Expr::UnaryOp(crate::ExprUnaryOp {
+                op,
+                operand,
+                range: _range,
+            }) => {
                 let (op, prec) = op_prec!(
                     un,
                     op,
@@ -132,7 +147,11 @@ impl<'a> Unparser<'a> {
                     self.unparse_expr(operand, prec)?;
                 })
             }
-            ExprKind::Lambda(crate::ExprLambda { args, body }) => {
+            Expr::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 +159,12 @@ impl<'a> Unparser<'a> {
                     write!(self, ": {}", **body)?;
                 })
             }
-            ExprKind::IfExp(crate::ExprIfExp { test, body, orelse }) => {
+            Expr::IfExp(crate::ExprIfExp {
+                test,
+                body,
+                orelse,
+                range: _range,
+            }) => {
                 group_if!(precedence::TEST, {
                     self.unparse_expr(body, precedence::TEST + 1)?;
                     self.p(" if ")?;
@@ -149,7 +173,11 @@ impl<'a> Unparser<'a> {
                     self.unparse_expr(orelse, precedence::TEST)?;
                 })
             }
-            ExprKind::Dict(crate::ExprDict { keys, values }) => {
+            Expr::Dict(crate::ExprDict {
+                keys,
+                values,
+                range: _range,
+            }) => {
                 self.p("{")?;
                 let mut first = true;
                 let (packed, unpacked) = values.split_at(keys.len());
@@ -167,7 +195,10 @@ impl<'a> Unparser<'a> {
                 }
                 self.p("}")?;
             }
-            ExprKind::Set(crate::ExprSet { elts }) => {
+            Expr::Set(crate::ExprSet {
+                elts,
+                range: _range,
+            }) => {
                 self.p("{")?;
                 let mut first = true;
                 for v in elts {
@@ -176,22 +207,31 @@ impl<'a> Unparser<'a> {
                 }
                 self.p("}")?;
             }
-            ExprKind::ListComp(crate::ExprListComp { elt, generators }) => {
+            Expr::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 }) => {
+            Expr::SetComp(crate::ExprSetComp {
+                elt,
+                generators,
+                range: _range,
+            }) => {
                 self.p("{")?;
                 self.unparse_expr(elt, precedence::TEST)?;
                 self.unparse_comp(generators)?;
                 self.p("}")?;
             }
-            ExprKind::DictComp(crate::ExprDictComp {
+            Expr::DictComp(crate::ExprDictComp {
                 key,
                 value,
                 generators,
+                range: _range,
             }) => {
                 self.p("{")?;
                 self.unparse_expr(key, precedence::TEST)?;
@@ -200,32 +240,46 @@ impl<'a> Unparser<'a> {
                 self.unparse_comp(generators)?;
                 self.p("}")?;
             }
-            ExprKind::GeneratorExp(crate::ExprGeneratorExp { elt, generators }) => {
+            Expr::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 }) => {
+            Expr::Await(crate::ExprAwait {
+                value,
+                range: _range,
+            }) => {
                 group_if!(precedence::AWAIT, {
                     self.p("await ")?;
                     self.unparse_expr(value, precedence::ATOM)?;
                 })
             }
-            ExprKind::Yield(crate::ExprYield { value }) => {
+            Expr::Yield(crate::ExprYield {
+                value,
+                range: _range,
+            }) => {
                 if let Some(value) = value {
                     write!(self, "(yield {})", **value)?;
                 } else {
                     self.p("(yield)")?;
                 }
             }
-            ExprKind::YieldFrom(crate::ExprYieldFrom { value }) => {
+            Expr::YieldFrom(crate::ExprYieldFrom {
+                value,
+                range: _range,
+            }) => {
                 write!(self, "(yield from {})", **value)?;
             }
-            ExprKind::Compare(crate::ExprCompare {
+            Expr::Compare(crate::ExprCompare {
                 left,
                 ops,
                 comparators,
+                range: _range,
             }) => {
                 group_if!(precedence::CMP, {
                     let new_lvl = precedence::CMP + 1;
@@ -248,18 +302,20 @@ impl<'a> Unparser<'a> {
                     }
                 })
             }
-            ExprKind::Call(crate::ExprCall {
+            Expr::Call(crate::ExprCall {
                 func,
                 args,
                 keywords,
+                range: _range,
             }) => {
                 self.unparse_expr(func, precedence::ATOM)?;
                 self.p("(")?;
                 if let (
-                    [Expr {
-                        node: ExprKind::GeneratorExp(crate::ExprGeneratorExp { elt, generators }),
-                        ..
-                    }],
+                    [Expr::GeneratorExp(crate::ExprGeneratorExp {
+                        elt,
+                        generators,
+                        range: _range,
+                    })],
                     [],
                 ) = (&**args, &**keywords)
                 {
@@ -274,26 +330,32 @@ 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(")")?;
             }
-            ExprKind::FormattedValue(crate::ExprFormattedValue {
+            Expr::FormattedValue(crate::ExprFormattedValue {
                 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 }) => {
+            Expr::JoinedStr(crate::ExprJoinedStr {
+                values,
+                range: _range,
+            }) => self.unparse_joined_str(values, false)?,
+            Expr::Constant(crate::ExprConstant {
+                value,
+                kind,
+                range: _range,
+            }) => {
                 if let Some(kind) = kind {
                     self.p(kind)?;
                 }
@@ -309,12 +371,12 @@ impl<'a> Unparser<'a> {
                     _ => fmt::Display::fmt(value, &mut self.f)?,
                 }
             }
-            ExprKind::Attribute(crate::ExprAttribute { value, attr, .. }) => {
+            Expr::Attribute(crate::ExprAttribute { value, attr, .. }) => {
                 self.unparse_expr(value, precedence::ATOM)?;
-                let period = if let ExprKind::Constant(crate::ExprConstant {
+                let period = if let Expr::Constant(crate::ExprConstant {
                     value: Constant::Int(_),
                     ..
-                }) = &value.node
+                }) = value.as_ref()
                 {
                     " ."
                 } else {
@@ -323,14 +385,11 @@ impl<'a> Unparser<'a> {
                 self.p(period)?;
                 self.p_id(attr)?;
             }
-            ExprKind::Subscript(crate::ExprSubscript { value, slice, .. }) => {
+            Expr::Subscript(crate::ExprSubscript { value, slice, .. }) => {
                 self.unparse_expr(value, precedence::ATOM)?;
                 let mut lvl = precedence::TUPLE;
-                if let ExprKind::Tuple(crate::ExprTuple { elts, .. }) = &slice.node {
-                    if elts
-                        .iter()
-                        .any(|expr| matches!(expr.node, ExprKind::Starred { .. }))
-                    {
+                if let Expr::Tuple(crate::ExprTuple { elts, .. }) = slice.as_ref() {
+                    if elts.iter().any(|expr| expr.is_starred_expr()) {
                         lvl += 1
                     }
                 }
@@ -338,12 +397,12 @@ impl<'a> Unparser<'a> {
                 self.unparse_expr(slice, lvl)?;
                 self.p("]")?;
             }
-            ExprKind::Starred(crate::ExprStarred { value, .. }) => {
+            Expr::Starred(crate::ExprStarred { value, .. }) => {
                 self.p("*")?;
                 self.unparse_expr(value, precedence::EXPR)?;
             }
-            ExprKind::Name(crate::ExprName { id, .. }) => self.p_id(id)?,
-            ExprKind::List(crate::ExprList { elts, .. }) => {
+            Expr::Name(crate::ExprName { id, .. }) => self.p_id(id)?,
+            Expr::List(crate::ExprList { elts, .. }) => {
                 self.p("[")?;
                 let mut first = true;
                 for elt in elts {
@@ -352,7 +411,7 @@ impl<'a> Unparser<'a> {
                 }
                 self.p("]")?;
             }
-            ExprKind::Tuple(crate::ExprTuple { elts, .. }) => {
+            Expr::Tuple(crate::ExprTuple { elts, .. }) => {
                 if elts.is_empty() {
                     self.p("()")?;
                 } else {
@@ -366,7 +425,12 @@ impl<'a> Unparser<'a> {
                     })
                 }
             }
-            ExprKind::Slice(crate::ExprSlice { lower, upper, step }) => {
+            Expr::Slice(crate::ExprSlice {
+                lower,
+                upper,
+                step,
+                range: _range,
+            }) => {
                 if let Some(lower) = lower {
                     self.unparse_expr(lower, precedence::TEST)?;
                 }
@@ -420,8 +484,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(())
@@ -487,21 +551,23 @@ impl<'a> Unparser<'a> {
     }
 
     fn unparse_fstring_elem<U>(&mut self, expr: &Expr<U>, is_spec: bool) -> fmt::Result {
-        match &expr.node {
-            ExprKind::Constant(crate::ExprConstant { value, .. }) => {
+        match &expr {
+            Expr::Constant(crate::ExprConstant { value, .. }) => {
                 if let Constant::Str(s) = value {
                     self.unparse_fstring_str(s)
                 } else {
                     unreachable!()
                 }
             }
-            ExprKind::JoinedStr(crate::ExprJoinedStr { values }) => {
-                self.unparse_joined_str(values, is_spec)
-            }
-            ExprKind::FormattedValue(crate::ExprFormattedValue {
+            Expr::JoinedStr(crate::ExprJoinedStr {
+                values,
+                range: _range,
+            }) => self.unparse_joined_str(values, is_spec),
+            Expr::FormattedValue(crate::ExprFormattedValue {
                 value,
                 conversion,
                 format_spec,
+                range: _range,
             }) => self.unparse_formatted(value, conversion.to_u32(), format_spec.as_deref()),
             _ => unreachable!(),
         }