diff --git a/ast/Cargo.toml b/ast/Cargo.toml
index 77fafd0..fe1c39e 100644
--- a/ast/Cargo.toml
+++ b/ast/Cargo.toml
@@ -22,3 +22,4 @@ rustpython-literal = { workspace = true, optional = true }
 
 is-macro = { workspace = true }
 num-bigint = { workspace = true }
+static_assertions = "1.1.0"
diff --git a/ast/asdl_rs.py b/ast/asdl_rs.py
index 90e0752..e77069e 100755
--- a/ast/asdl_rs.py
+++ b/ast/asdl_rs.py
@@ -1,6 +1,6 @@
 # spell-checker:words dfn dfns
 
-#! /usr/bin/env python
+# ! /usr/bin/env python
 """Generate Rust code from an ASDL description."""
 
 import sys
@@ -362,17 +362,17 @@ class StructVisitor(EmitVisitor):
             typ = f"{typ}<R>"
         # don't box if we're doing Vec<T>, but do box if we're doing Vec<Option<Box<T>>>
         if (
-            field_type
-            and field_type.boxed
-            and (not (parent.product or field.seq) or field.opt)
+                field_type
+                and field_type.boxed
+                and (not (parent.product or field.seq) or field.opt)
         ):
             typ = f"Box<{typ}>"
         if field.opt or (
-            # When a dictionary literal contains dictionary unpacking (e.g., `{**d}`),
-            # the expression to be unpacked goes in `values` with a `None` at the corresponding
-            # position in `keys`. To handle this, the type of `keys` needs to be `Option<Vec<T>>`.
-            constructor == "Dict"
-            and field.name == "keys"
+                # When a dictionary literal contains dictionary unpacking (e.g., `{**d}`),
+                # the expression to be unpacked goes in `values` with a `None` at the corresponding
+                # position in `keys`. To handle this, the type of `keys` needs to be `Option<Vec<T>>`.
+                constructor == "Dict"
+                and field.name == "keys"
         ):
             typ = f"Option<{typ}>"
         if field.seq:
@@ -939,16 +939,32 @@ class RangedDefVisitor(EmitVisitor):
         if info.is_simple:
             return
 
+        sum_match_arms = ""
+
         for ty in sum.types:
-            info = self.type_info[ty.name]
-            self.make_ranged_impl(info)
+            variant_info = self.type_info[ty.name]
+            sum_match_arms += f"        Self::{variant_info.rust_name}(node) => node.range(),"
+            self.emit_ranged_impl(variant_info)
+
+        if not info.no_cfg(self.type_info):
+            self.emit('#[cfg(feature = "more-attributes")]', 0)
+
+        self.emit(f"""
+        impl Ranged for crate::{info.rust_sum_name} {{
+            fn range(&self) -> TextRange {{
+                match self {{
+                    {sum_match_arms}
+                }}
+            }}
+        }}
+        """.lstrip(), 0)
 
     def visitProduct(self, product, name, depth):
         info = self.type_info[name]
 
-        self.make_ranged_impl(info)
+        self.emit_ranged_impl(info)
 
-    def make_ranged_impl(self, info):
+    def emit_ranged_impl(self, info):
         if not info.no_cfg(self.type_info):
             self.emit('#[cfg(feature = "more-attributes")]', 0)
 
@@ -962,6 +978,7 @@ class RangedDefVisitor(EmitVisitor):
             """.strip()
         )
 
+
 class LocatedDefVisitor(EmitVisitor):
     def visitModule(self, mod):
         for dfn in mod.dfns:
@@ -973,36 +990,58 @@ class LocatedDefVisitor(EmitVisitor):
     def visitSum(self, sum, name, depth):
         info = self.type_info[name]
 
+        self.emit_type_alias(info)
+
         if info.is_simple:
             return
 
+        sum_match_arms = ""
+
         for ty in sum.types:
-            info = self.type_info[ty.name]
-            self.make_located_impl(info)
+            variant_info = self.type_info[ty.name]
+            sum_match_arms += f"        Self::{variant_info.rust_name}(node) => node.range(),"
+            self.emit_type_alias(variant_info)
+            self.emit_located_impl(variant_info)
+
+        if not info.no_cfg(self.type_info):
+            self.emit('#[cfg(feature = "more-attributes")]', 0)
+
+        self.emit(f"""
+        impl Located for {info.rust_sum_name} {{
+            fn range(&self) -> SourceRange {{
+                match self {{
+                    {sum_match_arms}
+                }}
+            }}
+        }}
+        """.lstrip(), 0)
 
     def visitProduct(self, product, name, depth):
         info = self.type_info[name]
 
-        self.make_located_impl(info)
+        self.emit_type_alias(info)
+        self.emit_located_impl(info)
 
-    def make_located_impl(self, info):
+    def emit_type_alias(self, info):
+        generics = "" if info.is_simple else "::<SourceRange>"
+
+        self.emit(f"pub type {info.rust_sum_name} = crate::generic::{info.rust_sum_name}{generics};", 0)
+        self.emit("", 0)
+
+    def emit_located_impl(self, info):
         if not info.no_cfg(self.type_info):
             self.emit('#[cfg(feature = "more-attributes")]', 0)
 
-        self.emit(f"pub type {info.rust_sum_name} = crate::generic::{info.rust_sum_name}::<SourceRange>;", 0)
-
-        if not info.no_cfg(self.type_info):
-            self.emit('#[cfg(feature = "more-attributes")]', 0)
-
-        self.file.write(
+        self.emit(
             f"""
             impl Located for {info.rust_sum_name} {{
                 fn range(&self) -> SourceRange {{
                     self.range
                 }}
             }}
-            """.strip()
-        )
+            """
+            , 0)
+
 
 class ChainOfVisitors:
     def __init__(self, *visitors):
@@ -1035,6 +1074,7 @@ def write_ranged_def(mod, type_info, f):
 def write_located_def(mod, type_info, f):
     LocatedDefVisitor(f, type_info).visit(mod)
 
+
 def write_ast_mod(mod, type_info, f):
     f.write(
         textwrap.dedent(
@@ -1056,10 +1096,10 @@ def write_ast_mod(mod, type_info, f):
 
 
 def main(
-    input_filename,
-    ast_dir,
-    module_filename,
-    dump_module=False,
+        input_filename,
+        ast_dir,
+        module_filename,
+        dump_module=False,
 ):
     auto_gen_msg = AUTO_GEN_MESSAGE.format("/".join(Path(__file__).parts[-2:]))
     mod = asdl.parse(input_filename)
diff --git a/ast/src/gen/located.rs b/ast/src/gen/located.rs
index 8b124dd..b5a11a2 100644
--- a/ast/src/gen/located.rs
+++ b/ast/src/gen/located.rs
@@ -1,470 +1,753 @@
 // File automatically generated by ast/asdl_rs.py.
 
-#[cfg(feature = "more-attributes")]
+pub type Mod = crate::generic::Mod<SourceRange>;
+
 pub type ModModule = crate::generic::ModModule<SourceRange>;
+
 #[cfg(feature = "more-attributes")]
+
 impl Located for ModModule {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
-#[cfg(feature = "more-attributes")]
+
 pub type ModInteractive = crate::generic::ModInteractive<SourceRange>;
+
 #[cfg(feature = "more-attributes")]
+
 impl Located for ModInteractive {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
-#[cfg(feature = "more-attributes")]
+
 pub type ModExpression = crate::generic::ModExpression<SourceRange>;
+
 #[cfg(feature = "more-attributes")]
+
 impl Located for ModExpression {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
-#[cfg(feature = "more-attributes")]
+
 pub type ModFunctionType = crate::generic::ModFunctionType<SourceRange>;
+
 #[cfg(feature = "more-attributes")]
+
 impl Located for ModFunctionType {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
+#[cfg(feature = "more-attributes")]
+impl Located for Mod {
+    fn range(&self) -> SourceRange {
+        match self {
+            Self::Module(node) => node.range(),
+            Self::Interactive(node) => node.range(),
+            Self::Expression(node) => node.range(),
+            Self::FunctionType(node) => node.range(),
+        }
+    }
+}
+
+pub type Stmt = crate::generic::Stmt<SourceRange>;
+
 pub type StmtFunctionDef = crate::generic::StmtFunctionDef<SourceRange>;
+
 impl Located for StmtFunctionDef {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type StmtAsyncFunctionDef = crate::generic::StmtAsyncFunctionDef<SourceRange>;
+
 impl Located for StmtAsyncFunctionDef {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type StmtClassDef = crate::generic::StmtClassDef<SourceRange>;
+
 impl Located for StmtClassDef {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type StmtReturn = crate::generic::StmtReturn<SourceRange>;
+
 impl Located for StmtReturn {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type StmtDelete = crate::generic::StmtDelete<SourceRange>;
+
 impl Located for StmtDelete {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type StmtAssign = crate::generic::StmtAssign<SourceRange>;
+
 impl Located for StmtAssign {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type StmtAugAssign = crate::generic::StmtAugAssign<SourceRange>;
+
 impl Located for StmtAugAssign {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type StmtAnnAssign = crate::generic::StmtAnnAssign<SourceRange>;
+
 impl Located for StmtAnnAssign {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type StmtFor = crate::generic::StmtFor<SourceRange>;
+
 impl Located for StmtFor {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type StmtAsyncFor = crate::generic::StmtAsyncFor<SourceRange>;
+
 impl Located for StmtAsyncFor {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type StmtWhile = crate::generic::StmtWhile<SourceRange>;
+
 impl Located for StmtWhile {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type StmtIf = crate::generic::StmtIf<SourceRange>;
+
 impl Located for StmtIf {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type StmtWith = crate::generic::StmtWith<SourceRange>;
+
 impl Located for StmtWith {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type StmtAsyncWith = crate::generic::StmtAsyncWith<SourceRange>;
+
 impl Located for StmtAsyncWith {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type StmtMatch = crate::generic::StmtMatch<SourceRange>;
+
 impl Located for StmtMatch {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type StmtRaise = crate::generic::StmtRaise<SourceRange>;
+
 impl Located for StmtRaise {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type StmtTry = crate::generic::StmtTry<SourceRange>;
+
 impl Located for StmtTry {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type StmtTryStar = crate::generic::StmtTryStar<SourceRange>;
+
 impl Located for StmtTryStar {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type StmtAssert = crate::generic::StmtAssert<SourceRange>;
+
 impl Located for StmtAssert {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type StmtImport = crate::generic::StmtImport<SourceRange>;
+
 impl Located for StmtImport {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type StmtImportFrom = crate::generic::StmtImportFrom<SourceRange>;
+
 impl Located for StmtImportFrom {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type StmtGlobal = crate::generic::StmtGlobal<SourceRange>;
+
 impl Located for StmtGlobal {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type StmtNonlocal = crate::generic::StmtNonlocal<SourceRange>;
+
 impl Located for StmtNonlocal {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type StmtExpr = crate::generic::StmtExpr<SourceRange>;
+
 impl Located for StmtExpr {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type StmtPass = crate::generic::StmtPass<SourceRange>;
+
 impl Located for StmtPass {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type StmtBreak = crate::generic::StmtBreak<SourceRange>;
+
 impl Located for StmtBreak {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type StmtContinue = crate::generic::StmtContinue<SourceRange>;
+
 impl Located for StmtContinue {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
+impl Located for Stmt {
+    fn range(&self) -> SourceRange {
+        match self {
+            Self::FunctionDef(node) => node.range(),
+            Self::AsyncFunctionDef(node) => node.range(),
+            Self::ClassDef(node) => node.range(),
+            Self::Return(node) => node.range(),
+            Self::Delete(node) => node.range(),
+            Self::Assign(node) => node.range(),
+            Self::AugAssign(node) => node.range(),
+            Self::AnnAssign(node) => node.range(),
+            Self::For(node) => node.range(),
+            Self::AsyncFor(node) => node.range(),
+            Self::While(node) => node.range(),
+            Self::If(node) => node.range(),
+            Self::With(node) => node.range(),
+            Self::AsyncWith(node) => node.range(),
+            Self::Match(node) => node.range(),
+            Self::Raise(node) => node.range(),
+            Self::Try(node) => node.range(),
+            Self::TryStar(node) => node.range(),
+            Self::Assert(node) => node.range(),
+            Self::Import(node) => node.range(),
+            Self::ImportFrom(node) => node.range(),
+            Self::Global(node) => node.range(),
+            Self::Nonlocal(node) => node.range(),
+            Self::Expr(node) => node.range(),
+            Self::Pass(node) => node.range(),
+            Self::Break(node) => node.range(),
+            Self::Continue(node) => node.range(),
+        }
+    }
+}
+
+pub type Expr = crate::generic::Expr<SourceRange>;
+
 pub type ExprBoolOp = crate::generic::ExprBoolOp<SourceRange>;
+
 impl Located for ExprBoolOp {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type ExprNamedExpr = crate::generic::ExprNamedExpr<SourceRange>;
+
 impl Located for ExprNamedExpr {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type ExprBinOp = crate::generic::ExprBinOp<SourceRange>;
+
 impl Located for ExprBinOp {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type ExprUnaryOp = crate::generic::ExprUnaryOp<SourceRange>;
+
 impl Located for ExprUnaryOp {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type ExprLambda = crate::generic::ExprLambda<SourceRange>;
+
 impl Located for ExprLambda {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type ExprIfExp = crate::generic::ExprIfExp<SourceRange>;
+
 impl Located for ExprIfExp {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type ExprDict = crate::generic::ExprDict<SourceRange>;
+
 impl Located for ExprDict {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type ExprSet = crate::generic::ExprSet<SourceRange>;
+
 impl Located for ExprSet {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type ExprListComp = crate::generic::ExprListComp<SourceRange>;
+
 impl Located for ExprListComp {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type ExprSetComp = crate::generic::ExprSetComp<SourceRange>;
+
 impl Located for ExprSetComp {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type ExprDictComp = crate::generic::ExprDictComp<SourceRange>;
+
 impl Located for ExprDictComp {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type ExprGeneratorExp = crate::generic::ExprGeneratorExp<SourceRange>;
+
 impl Located for ExprGeneratorExp {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type ExprAwait = crate::generic::ExprAwait<SourceRange>;
+
 impl Located for ExprAwait {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type ExprYield = crate::generic::ExprYield<SourceRange>;
+
 impl Located for ExprYield {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type ExprYieldFrom = crate::generic::ExprYieldFrom<SourceRange>;
+
 impl Located for ExprYieldFrom {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type ExprCompare = crate::generic::ExprCompare<SourceRange>;
+
 impl Located for ExprCompare {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type ExprCall = crate::generic::ExprCall<SourceRange>;
+
 impl Located for ExprCall {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type ExprFormattedValue = crate::generic::ExprFormattedValue<SourceRange>;
+
 impl Located for ExprFormattedValue {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type ExprJoinedStr = crate::generic::ExprJoinedStr<SourceRange>;
+
 impl Located for ExprJoinedStr {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type ExprConstant = crate::generic::ExprConstant<SourceRange>;
+
 impl Located for ExprConstant {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type ExprAttribute = crate::generic::ExprAttribute<SourceRange>;
+
 impl Located for ExprAttribute {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type ExprSubscript = crate::generic::ExprSubscript<SourceRange>;
+
 impl Located for ExprSubscript {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type ExprStarred = crate::generic::ExprStarred<SourceRange>;
+
 impl Located for ExprStarred {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type ExprName = crate::generic::ExprName<SourceRange>;
+
 impl Located for ExprName {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type ExprList = crate::generic::ExprList<SourceRange>;
+
 impl Located for ExprList {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type ExprTuple = crate::generic::ExprTuple<SourceRange>;
+
 impl Located for ExprTuple {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type ExprSlice = crate::generic::ExprSlice<SourceRange>;
+
 impl Located for ExprSlice {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
-#[cfg(feature = "more-attributes")]
+
+impl Located for Expr {
+    fn range(&self) -> SourceRange {
+        match self {
+            Self::BoolOp(node) => node.range(),
+            Self::NamedExpr(node) => node.range(),
+            Self::BinOp(node) => node.range(),
+            Self::UnaryOp(node) => node.range(),
+            Self::Lambda(node) => node.range(),
+            Self::IfExp(node) => node.range(),
+            Self::Dict(node) => node.range(),
+            Self::Set(node) => node.range(),
+            Self::ListComp(node) => node.range(),
+            Self::SetComp(node) => node.range(),
+            Self::DictComp(node) => node.range(),
+            Self::GeneratorExp(node) => node.range(),
+            Self::Await(node) => node.range(),
+            Self::Yield(node) => node.range(),
+            Self::YieldFrom(node) => node.range(),
+            Self::Compare(node) => node.range(),
+            Self::Call(node) => node.range(),
+            Self::FormattedValue(node) => node.range(),
+            Self::JoinedStr(node) => node.range(),
+            Self::Constant(node) => node.range(),
+            Self::Attribute(node) => node.range(),
+            Self::Subscript(node) => node.range(),
+            Self::Starred(node) => node.range(),
+            Self::Name(node) => node.range(),
+            Self::List(node) => node.range(),
+            Self::Tuple(node) => node.range(),
+            Self::Slice(node) => node.range(),
+        }
+    }
+}
+
+pub type ExprContext = crate::generic::ExprContext;
+
+pub type Boolop = crate::generic::Boolop;
+
+pub type Operator = crate::generic::Operator;
+
+pub type Unaryop = crate::generic::Unaryop;
+
+pub type Cmpop = crate::generic::Cmpop;
+
 pub type Comprehension = crate::generic::Comprehension<SourceRange>;
+
 #[cfg(feature = "more-attributes")]
+
 impl Located for Comprehension {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
+pub type Excepthandler = crate::generic::Excepthandler<SourceRange>;
+
 pub type ExcepthandlerExceptHandler = crate::generic::ExcepthandlerExceptHandler<SourceRange>;
+
 impl Located for ExcepthandlerExceptHandler {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
-#[cfg(feature = "more-attributes")]
+
+impl Located for Excepthandler {
+    fn range(&self) -> SourceRange {
+        match self {
+            Self::ExceptHandler(node) => node.range(),
+        }
+    }
+}
+
 pub type Arguments = crate::generic::Arguments<SourceRange>;
+
 #[cfg(feature = "more-attributes")]
+
 impl Located for Arguments {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type Arg = crate::generic::Arg<SourceRange>;
+
 impl Located for Arg {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type Keyword = crate::generic::Keyword<SourceRange>;
+
 impl Located for Keyword {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type Alias = crate::generic::Alias<SourceRange>;
+
 impl Located for Alias {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
-#[cfg(feature = "more-attributes")]
+
 pub type Withitem = crate::generic::Withitem<SourceRange>;
+
 #[cfg(feature = "more-attributes")]
+
 impl Located for Withitem {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
-#[cfg(feature = "more-attributes")]
+
 pub type MatchCase = crate::generic::MatchCase<SourceRange>;
+
 #[cfg(feature = "more-attributes")]
+
 impl Located for MatchCase {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
+pub type Pattern = crate::generic::Pattern<SourceRange>;
+
 pub type PatternMatchValue = crate::generic::PatternMatchValue<SourceRange>;
+
 impl Located for PatternMatchValue {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type PatternMatchSingleton = crate::generic::PatternMatchSingleton<SourceRange>;
+
 impl Located for PatternMatchSingleton {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type PatternMatchSequence = crate::generic::PatternMatchSequence<SourceRange>;
+
 impl Located for PatternMatchSequence {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type PatternMatchMapping = crate::generic::PatternMatchMapping<SourceRange>;
+
 impl Located for PatternMatchMapping {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type PatternMatchClass = crate::generic::PatternMatchClass<SourceRange>;
+
 impl Located for PatternMatchClass {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type PatternMatchStar = crate::generic::PatternMatchStar<SourceRange>;
+
 impl Located for PatternMatchStar {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type PatternMatchAs = crate::generic::PatternMatchAs<SourceRange>;
+
 impl Located for PatternMatchAs {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
 pub type PatternMatchOr = crate::generic::PatternMatchOr<SourceRange>;
+
 impl Located for PatternMatchOr {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
-#[cfg(feature = "more-attributes")]
+
+impl Located for Pattern {
+    fn range(&self) -> SourceRange {
+        match self {
+            Self::MatchValue(node) => node.range(),
+            Self::MatchSingleton(node) => node.range(),
+            Self::MatchSequence(node) => node.range(),
+            Self::MatchMapping(node) => node.range(),
+            Self::MatchClass(node) => node.range(),
+            Self::MatchStar(node) => node.range(),
+            Self::MatchAs(node) => node.range(),
+            Self::MatchOr(node) => node.range(),
+        }
+    }
+}
+
+pub type TypeIgnore = crate::generic::TypeIgnore<SourceRange>;
+
 pub type TypeIgnoreTypeIgnore = crate::generic::TypeIgnoreTypeIgnore<SourceRange>;
+
 #[cfg(feature = "more-attributes")]
+
 impl Located for TypeIgnoreTypeIgnore {
     fn range(&self) -> SourceRange {
         self.range
     }
 }
+
+#[cfg(feature = "more-attributes")]
+impl Located for TypeIgnore {
+    fn range(&self) -> SourceRange {
+        match self {
+            Self::TypeIgnore(node) => node.range(),
+        }
+    }
+}
diff --git a/ast/src/gen/ranged.rs b/ast/src/gen/ranged.rs
index 3d948a6..10c424d 100644
--- a/ast/src/gen/ranged.rs
+++ b/ast/src/gen/ranged.rs
@@ -25,6 +25,18 @@ impl Ranged for crate::generic::ModFunctionType<TextRange> {
         self.range
     }
 }
+#[cfg(feature = "more-attributes")]
+impl Ranged for crate::Mod {
+    fn range(&self) -> TextRange {
+        match self {
+            Self::Module(node) => node.range(),
+            Self::Interactive(node) => node.range(),
+            Self::Expression(node) => node.range(),
+            Self::FunctionType(node) => node.range(),
+        }
+    }
+}
+
 impl Ranged for crate::generic::StmtFunctionDef<TextRange> {
     fn range(&self) -> TextRange {
         self.range
@@ -160,6 +172,40 @@ impl Ranged for crate::generic::StmtContinue<TextRange> {
         self.range
     }
 }
+impl Ranged for crate::Stmt {
+    fn range(&self) -> TextRange {
+        match self {
+            Self::FunctionDef(node) => node.range(),
+            Self::AsyncFunctionDef(node) => node.range(),
+            Self::ClassDef(node) => node.range(),
+            Self::Return(node) => node.range(),
+            Self::Delete(node) => node.range(),
+            Self::Assign(node) => node.range(),
+            Self::AugAssign(node) => node.range(),
+            Self::AnnAssign(node) => node.range(),
+            Self::For(node) => node.range(),
+            Self::AsyncFor(node) => node.range(),
+            Self::While(node) => node.range(),
+            Self::If(node) => node.range(),
+            Self::With(node) => node.range(),
+            Self::AsyncWith(node) => node.range(),
+            Self::Match(node) => node.range(),
+            Self::Raise(node) => node.range(),
+            Self::Try(node) => node.range(),
+            Self::TryStar(node) => node.range(),
+            Self::Assert(node) => node.range(),
+            Self::Import(node) => node.range(),
+            Self::ImportFrom(node) => node.range(),
+            Self::Global(node) => node.range(),
+            Self::Nonlocal(node) => node.range(),
+            Self::Expr(node) => node.range(),
+            Self::Pass(node) => node.range(),
+            Self::Break(node) => node.range(),
+            Self::Continue(node) => node.range(),
+        }
+    }
+}
+
 impl Ranged for crate::generic::ExprBoolOp<TextRange> {
     fn range(&self) -> TextRange {
         self.range
@@ -295,6 +341,40 @@ impl Ranged for crate::generic::ExprSlice<TextRange> {
         self.range
     }
 }
+impl Ranged for crate::Expr {
+    fn range(&self) -> TextRange {
+        match self {
+            Self::BoolOp(node) => node.range(),
+            Self::NamedExpr(node) => node.range(),
+            Self::BinOp(node) => node.range(),
+            Self::UnaryOp(node) => node.range(),
+            Self::Lambda(node) => node.range(),
+            Self::IfExp(node) => node.range(),
+            Self::Dict(node) => node.range(),
+            Self::Set(node) => node.range(),
+            Self::ListComp(node) => node.range(),
+            Self::SetComp(node) => node.range(),
+            Self::DictComp(node) => node.range(),
+            Self::GeneratorExp(node) => node.range(),
+            Self::Await(node) => node.range(),
+            Self::Yield(node) => node.range(),
+            Self::YieldFrom(node) => node.range(),
+            Self::Compare(node) => node.range(),
+            Self::Call(node) => node.range(),
+            Self::FormattedValue(node) => node.range(),
+            Self::JoinedStr(node) => node.range(),
+            Self::Constant(node) => node.range(),
+            Self::Attribute(node) => node.range(),
+            Self::Subscript(node) => node.range(),
+            Self::Starred(node) => node.range(),
+            Self::Name(node) => node.range(),
+            Self::List(node) => node.range(),
+            Self::Tuple(node) => node.range(),
+            Self::Slice(node) => node.range(),
+        }
+    }
+}
+
 #[cfg(feature = "more-attributes")]
 impl Ranged for crate::generic::Comprehension<TextRange> {
     fn range(&self) -> TextRange {
@@ -306,6 +386,14 @@ impl Ranged for crate::generic::ExcepthandlerExceptHandler<TextRange> {
         self.range
     }
 }
+impl Ranged for crate::Excepthandler {
+    fn range(&self) -> TextRange {
+        match self {
+            Self::ExceptHandler(node) => node.range(),
+        }
+    }
+}
+
 #[cfg(feature = "more-attributes")]
 impl Ranged for crate::generic::Arguments<TextRange> {
     fn range(&self) -> TextRange {
@@ -379,9 +467,32 @@ impl Ranged for crate::generic::PatternMatchOr<TextRange> {
         self.range
     }
 }
+impl Ranged for crate::Pattern {
+    fn range(&self) -> TextRange {
+        match self {
+            Self::MatchValue(node) => node.range(),
+            Self::MatchSingleton(node) => node.range(),
+            Self::MatchSequence(node) => node.range(),
+            Self::MatchMapping(node) => node.range(),
+            Self::MatchClass(node) => node.range(),
+            Self::MatchStar(node) => node.range(),
+            Self::MatchAs(node) => node.range(),
+            Self::MatchOr(node) => node.range(),
+        }
+    }
+}
+
 #[cfg(feature = "more-attributes")]
 impl Ranged for crate::generic::TypeIgnoreTypeIgnore<TextRange> {
     fn range(&self) -> TextRange {
         self.range
     }
 }
+#[cfg(feature = "more-attributes")]
+impl Ranged for crate::TypeIgnore {
+    fn range(&self) -> TextRange {
+        match self {
+            Self::TypeIgnore(node) => node.range(),
+        }
+    }
+}
diff --git a/ast/src/impls.rs b/ast/src/impls.rs
index f06d336..d00c973 100644
--- a/ast/src/impls.rs
+++ b/ast/src/impls.rs
@@ -1,5 +1,5 @@
-use crate::text_size::TextRange;
-use crate::{Constant, Excepthandler, Expr, Pattern, Ranged, Stmt};
+use crate::{Constant, Excepthandler, Expr, Pattern, Stmt};
+use static_assertions::const_assert_eq;
 
 impl<R> Expr<R> {
     /// Returns a short name for the node suitable for use in error messages.
@@ -55,93 +55,7 @@ impl<R> Expr<R> {
     }
 }
 
-impl Ranged for Expr<TextRange> {
-    fn range(&self) -> TextRange {
-        match self {
-            Expr::BoolOp(node) => node.range(),
-            Expr::NamedExpr(node) => node.range(),
-            Expr::BinOp(node) => node.range(),
-            Expr::UnaryOp(node) => node.range(),
-            Expr::Lambda(node) => node.range(),
-            Expr::IfExp(node) => node.range(),
-            Expr::Dict(node) => node.range(),
-            Expr::Set(node) => node.range(),
-            Expr::ListComp(node) => node.range(),
-            Expr::SetComp(node) => node.range(),
-            Expr::DictComp(node) => node.range(),
-            Expr::GeneratorExp(node) => node.range(),
-            Expr::Await(node) => node.range(),
-            Expr::Yield(node) => node.range(),
-            Expr::YieldFrom(node) => node.range(),
-            Expr::Compare(node) => node.range(),
-            Expr::Call(node) => node.range(),
-            Expr::FormattedValue(node) => node.range(),
-            Expr::JoinedStr(node) => node.range(),
-            Expr::Constant(node) => node.range(),
-            Expr::Attribute(node) => node.range(),
-            Expr::Subscript(node) => node.range(),
-            Expr::Starred(node) => node.range(),
-            Expr::Name(node) => node.range(),
-            Expr::List(node) => node.range(),
-            Expr::Tuple(node) => node.range(),
-            Expr::Slice(node) => node.range(),
-        }
-    }
-}
-
-impl Ranged for Stmt<TextRange> {
-    fn range(&self) -> TextRange {
-        match self {
-            Stmt::FunctionDef(stmt) => stmt.range(),
-            Stmt::AsyncFunctionDef(stmt) => stmt.range(),
-            Stmt::ClassDef(stmt) => stmt.range(),
-            Stmt::Return(stmt) => stmt.range(),
-            Stmt::Delete(stmt) => stmt.range(),
-            Stmt::Assign(stmt) => stmt.range(),
-            Stmt::AugAssign(stmt) => stmt.range(),
-            Stmt::AnnAssign(stmt) => stmt.range(),
-            Stmt::For(stmt) => stmt.range(),
-            Stmt::AsyncFor(stmt) => stmt.range(),
-            Stmt::While(stmt) => stmt.range(),
-            Stmt::If(stmt) => stmt.range(),
-            Stmt::With(stmt) => stmt.range(),
-            Stmt::AsyncWith(stmt) => stmt.range(),
-            Stmt::Match(stmt) => stmt.range(),
-            Stmt::Raise(stmt) => stmt.range(),
-            Stmt::Try(stmt) => stmt.range(),
-            Stmt::TryStar(stmt) => stmt.range(),
-            Stmt::Assert(stmt) => stmt.range(),
-            Stmt::Import(stmt) => stmt.range(),
-            Stmt::ImportFrom(stmt) => stmt.range(),
-            Stmt::Global(stmt) => stmt.range(),
-            Stmt::Nonlocal(stmt) => stmt.range(),
-            Stmt::Expr(stmt) => stmt.range(),
-            Stmt::Pass(stmt) => stmt.range(),
-            Stmt::Break(stmt) => stmt.range(),
-            Stmt::Continue(stmt) => stmt.range(),
-        }
-    }
-}
-
-impl Ranged for Pattern<TextRange> {
-    fn range(&self) -> TextRange {
-        match self {
-            Pattern::MatchValue(pattern) => pattern.range(),
-            Pattern::MatchSingleton(pattern) => pattern.range(),
-            Pattern::MatchSequence(pattern) => pattern.range(),
-            Pattern::MatchMapping(pattern) => pattern.range(),
-            Pattern::MatchClass(pattern) => pattern.range(),
-            Pattern::MatchStar(pattern) => pattern.range(),
-            Pattern::MatchAs(pattern) => pattern.range(),
-            Pattern::MatchOr(pattern) => pattern.range(),
-        }
-    }
-}
-
-impl Ranged for Excepthandler<TextRange> {
-    fn range(&self) -> TextRange {
-        match self {
-            Excepthandler::ExceptHandler(handler) => handler.range(),
-        }
-    }
-}
+const_assert_eq!(std::mem::size_of::<Expr>(), 72);
+const_assert_eq!(std::mem::size_of::<Stmt>(), 136);
+const_assert_eq!(std::mem::size_of::<Pattern>(), 96);
+const_assert_eq!(std::mem::size_of::<Excepthandler>(), 64);
diff --git a/ast/src/unparse.rs b/ast/src/unparse.rs
index 4d984a1..b68be60 100644
--- a/ast/src/unparse.rs
+++ b/ast/src/unparse.rs
@@ -389,10 +389,7 @@ impl<'a> Unparser<'a> {
                 self.unparse_expr(value, precedence::ATOM)?;
                 let mut lvl = precedence::TUPLE;
                 if let Expr::Tuple(crate::ExprTuple { elts, .. }) = slice.as_ref() {
-                    if elts
-                        .iter()
-                        .any(|expr| expr.is_starred_expr())
-                    {
+                    if elts.iter().any(|expr| expr.is_starred_expr()) {
                         lvl += 1
                     }
                 }