diff --git a/ast/asdl_rs.py b/ast/asdl_rs.py
index 359e29d..bb98706 100755
--- a/ast/asdl_rs.py
+++ b/ast/asdl_rs.py
@@ -106,7 +106,7 @@ class TypeInfo:
     def __repr__(self):
         return f"<TypeInfo: {self.name}>"
 
-    def needs_cfg(self, typeinfo):
+    def no_cfg(self, typeinfo):
         if self.product:
             return self.has_attributes
         elif self.enum_name:
@@ -157,7 +157,8 @@ class TypeInfoMixin:
         return self.type_info[typ].has_user_data
 
     def apply_generics(self, typ, *generics):
-        if self.has_user_data(typ):
+        needs_generics = not self.type_info[typ].is_simple
+        if needs_generics:
             return [f"<{g}>" for g in generics]
         else:
             return ["" for g in generics]
@@ -284,7 +285,6 @@ class StructVisitor(EmitVisitor):
             self.emit('#[cfg(not(feature = "more-attributes"))]', depth + 1)
             self.emit("pub custom: std::marker::PhantomData<U>,", depth + 1)
 
-
     def simple_sum(self, sum, name, depth):
         rust_name = rust_type_name(name)
         self.emit_attrs(depth)
@@ -314,9 +314,7 @@ class StructVisitor(EmitVisitor):
                     f'#[is(name = "{rust_field_name(t.name)}_{rust_name.lower()}")]',
                     depth + 1,
                 )
-            self.emit(
-                f"{t.name}({rust_name}{t.name}<U>),", depth + 1
-            )
+            self.emit(f"{t.name}({rust_name}{t.name}<U>),", depth + 1)
         self.emit("}", depth)
         self.emit("", depth)
 
@@ -327,9 +325,11 @@ class StructVisitor(EmitVisitor):
         for f in t.fields:
             self.visit(f, sum_type_info, "pub ", depth + 1, t.name)
 
-        assert sum_type_info.has_attributes == self.type_info[t.name].needs_cfg(self.type_info)
+        assert sum_type_info.has_attributes == self.type_info[t.name].no_cfg(
+            self.type_info
+        )
         self.emit_custom(sum_type_info.has_attributes, depth)
-            
+
         self.emit("}", depth)
         self.emit(
             textwrap.dedent(
@@ -398,7 +398,7 @@ class StructVisitor(EmitVisitor):
         self.emit(f"pub struct {product_name}<U> {{", depth)
         for f in product.fields:
             self.visit(f, type_info, "pub ", depth + 1)
-        assert bool(product.attributes) == type_info.needs_cfg(self.type_info)
+        assert bool(product.attributes) == type_info.no_cfg(self.type_info)
         self.emit_custom(product.attributes, depth + 1)
         self.emit("}", depth)
 
@@ -418,7 +418,17 @@ class FoldTraitDefVisitor(EmitVisitor):
         self.emit("type TargetU;", depth + 1)
         self.emit("type Error;", depth + 1)
         self.emit(
-            "fn map_user(&mut self, user: U) -> Result<Self::TargetU, Self::Error>;",
+            """
+            fn map_user(&mut self, user: U) -> Result<Self::TargetU, Self::Error>;
+            #[cfg(feature = "more-attributes")]
+            fn map_user_cfg(&mut self, user: U) -> Result<Self::TargetU, Self::Error> {
+                self.map_user(user)
+            }
+            #[cfg(not(feature = "more-attributes"))]
+            fn map_user_cfg(&mut self, _user: U) -> Result<std::marker::PhantomData<Self::TargetU>, Self::Error> {
+                Ok(std::marker::PhantomData)
+            }
+            """,
             depth + 1,
         )
         self.emit(
@@ -446,15 +456,6 @@ class FoldTraitDefVisitor(EmitVisitor):
 
 class FoldImplVisitor(EmitVisitor):
     def visitModule(self, mod, depth):
-        self.emit(
-            "fn fold_attributed<U, F: Fold<U> + ?Sized, T, MT>(folder: &mut F, node: Attributed<T, U>, f: impl FnOnce(&mut F, T) -> Result<MT, F::Error>) -> Result<Attributed<MT, F::TargetU>, F::Error> where T: Ranged{",
-            depth,
-        )
-        self.emit(
-            "let node = folder.map_attributed(node)?; Ok(Attributed { custom: node.custom, node: f(folder, node.node)? })",
-            depth + 1,
-        )
-        self.emit("}", depth)
         for dfn in mod.dfns:
             self.visit(dfn, depth)
 
@@ -483,25 +484,28 @@ class FoldImplVisitor(EmitVisitor):
             f"pub fn fold_{name}<U, F: Fold<U> + ?Sized>(#[allow(unused)] folder: &mut F, node: {enum_name}{apply_u}) -> Result<{enum_name}{apply_target_u}, F::Error> {{",
             depth,
         )
-        if type_info.has_attributes:
-            self.emit("fold_attributed(folder, node, |folder, node| {", depth)
+
+        if simple:
+            self.emit("Ok(node) }", depth + 1)
+            return
 
         self.emit("match node {", depth + 1)
         for cons in sum.types:
-            fields_pattern = self.make_pattern(
-                enum_name, cons.name, cons.fields, simple
-            )
+            fields_pattern = self.make_pattern(enum_name, cons.name, cons.fields)
             self.emit(
                 f"{fields_pattern[0]} {{ {fields_pattern[1]}}} {fields_pattern[2]} => {{",
                 depth + 2,
             )
+            if not type_info.has_attributes:
+                self.emit('#[cfg(not(feature = "more-attributes"))]', depth + 3)
+                self.emit("let custom = std::marker::PhantomData;", depth + 3)
+                self.emit('#[cfg(feature = "more-attributes")]', depth + 3)
+            self.emit("let custom = folder.map_user(custom)?;", depth + 3)
             self.gen_construction(
-                fields_pattern[0], cons.fields, fields_pattern[2], depth + 3, simple
+                fields_pattern[0], cons.fields, fields_pattern[2], depth + 3
             )
             self.emit("}", depth + 2)
         self.emit("}", depth + 1)
-        if type_info.has_attributes:
-            self.emit("})", depth)
         self.emit("}", depth)
 
     def visitProduct(self, product, name, depth):
@@ -525,41 +529,38 @@ class FoldImplVisitor(EmitVisitor):
             f"pub fn fold_{name}<U, F: Fold<U> + ?Sized>(#[allow(unused)] folder: &mut F, node: {struct_name}{apply_u}) -> Result<{struct_name}{apply_target_u}, F::Error> {{",
             depth,
         )
-        if has_attributes:
-            self.emit("fold_attributed(folder, node, |folder, node| {", depth)
-            rust_name = struct_name + "Data"
-        else:
-            rust_name = struct_name
-        fields_pattern = self.make_pattern(rust_name, struct_name, product.fields, False)
-        self.emit(f"let {rust_name} {{ {fields_pattern[1]} }} = node;", depth + 1)
-        self.gen_construction(rust_name, product.fields, "", depth + 1, False)
-        if has_attributes:
-            self.emit("})", depth)
+
+        fields_pattern = self.make_pattern(struct_name, struct_name, product.fields)
+        self.emit(f"let {struct_name} {{ {fields_pattern[1]} }} = node;", depth + 1)
+
+        if not has_attributes:
+            self.emit('#[cfg(not(feature = "more-attributes"))]', depth + 3)
+            self.emit("let custom = std::marker::PhantomData;", depth + 3)
+            self.emit('#[cfg(feature = "more-attributes")]', depth + 3)
+        self.emit("let custom = folder.map_user(custom)?;", depth + 3)
+
+        self.gen_construction(struct_name, product.fields, "", depth + 1)
+
         self.emit("}", depth)
 
-    def make_pattern(self, rust_name, fieldname: str, fields, simple_sum: bool):
-        if fields or not simple_sum:
-            header = f"{rust_name}::{fieldname}({rust_name}{fieldname}"
-            footer = ")"
-        else:
-            header = f"{rust_name}::{fieldname}"
-            footer = ""
+    def make_pattern(self, rust_name, fieldname: str, fields):
+        header = f"{rust_name}::{fieldname}({rust_name}{fieldname}"
+        footer = ")"
 
         body = ",".join(rust_field(f.name) for f in fields)
-
-        if not simple_sum:
-            body = f"range, {body}"
+        if body:
+            body += ","
+        body += "custom"
 
         return header, body, footer
 
-    def gen_construction(self, header, fields, footer, depth, simple_sum: bool):
+    def gen_construction(self, header, fields, footer, depth):
         self.emit(f"Ok({header} {{", depth)
         for field in fields:
             name = rust_field(field.name)
             self.emit(f"{name}: Foldable::fold({name}, folder)?,", depth + 1)
+        self.emit("custom,", depth + 1)
 
-        if not simple_sum:
-            self.emit("range", depth + 1)
         self.emit(f"}}{footer})", depth)
 
 
@@ -668,15 +669,13 @@ class VisitorTraitDefVisitor(StructVisitor):
         if not sum.attributes:
             return
 
-        rust_name = enum_name = rust_type_name(name)
-        if sum.attributes:
-            rust_name = enum_name + "Kind"
+        enum_name = rust_type_name(name)
         self.emit_visitor(name, depth)
         self.emit_generic_visitor_signature(name, depth)
         depth += 1
         self.emit("match node.node {", depth)
         for t in sum.types:
-            self.visit_match_for_type(name, rust_name, t, depth + 1)
+            self.visit_match_for_type(name, enum_name, t, depth + 1)
         self.emit("}", depth)
         depth -= 1
         self.emit("}", depth)
@@ -837,8 +836,6 @@ class TraitImplVisitor(EmitVisitor):
 
     def visitProduct(self, product, name, depth):
         struct_name = rust_type_name(name)
-        if product.attributes:
-            struct_name += "Data"
 
         self.emit(f"impl NamedNode for ast::located::{struct_name} {{", depth)
         self.emit(f"const NAME: &'static str = {json.dumps(name)};", depth + 1)
@@ -959,9 +956,11 @@ def write_ast_def(mod, type_info, f):
 
 
 def write_fold_def(mod, type_info, f):
-    f.write("""
+    f.write(
+        """
 use crate::generic::Custom;
-""")
+"""
+    )
     FoldModuleVisitor(f, type_info).visit(mod)
 
 
@@ -972,15 +971,17 @@ def write_visitor_def(mod, type_info, f):
 def write_ranged_def(mod, type_info, f):
     for info in type_info.values():
         if not info.is_simple:
-            if info.needs_cfg:
+            if info.no_cfg:
                 f.write('#[cfg(feature = "more-attributes")]')
-            f.write(f"""
+            f.write(
+                f"""
             impl Ranged for {info.rust_sum_name} {{
                 fn range(&self) -> TextRange {{
                     self.custom
                 }}
             }}
-            """)
+            """
+            )
             generics = "::<TextRange>"
         else:
             generics = ""
@@ -988,18 +989,21 @@ def write_ranged_def(mod, type_info, f):
             f"pub type {info.rust_sum_name} = crate::generic::{info.rust_sum_name}{generics};\n"
         )
 
+
 def write_located_def(mod, type_info, f):
     for info in type_info.values():
         if not info.is_simple:
-            if info.needs_cfg:
+            if info.no_cfg:
                 f.write('#[cfg(feature = "more-attributes")]')
-            f.write(f"""
+            f.write(
+                f"""
             impl Located for {info.rust_sum_name} {{
                 fn range(&self) -> SourceRange {{
                     self.custom
                 }}
             }}
-            """)
+            """
+            )
             generics = "::<SourceRange>"
         else:
             generics = ""
@@ -1007,6 +1011,7 @@ def write_located_def(mod, type_info, f):
             f"pub type {info.rust_sum_name} = crate::generic::{info.rust_sum_name}{generics};\n"
         )
 
+
 def write_ast_mod(mod, type_info, f):
     f.write(
         textwrap.dedent(
diff --git a/ast/src/gen/fold.rs b/ast/src/gen/fold.rs
index ad16434..238e749 100644
--- a/ast/src/gen/fold.rs
+++ b/ast/src/gen/fold.rs
@@ -5,7 +5,19 @@ use crate::generic::Custom;
 pub trait Fold<U> {
     type TargetU;
     type Error;
+
     fn map_user(&mut self, user: U) -> Result<Self::TargetU, Self::Error>;
+    #[cfg(feature = "more-attributes")]
+    fn map_user_cfg(&mut self, user: U) -> Result<Self::TargetU, Self::Error> {
+        self.map_user(user)
+    }
+    #[cfg(not(feature = "more-attributes"))]
+    fn map_user_cfg(
+        &mut self,
+        _user: U,
+    ) -> Result<std::marker::PhantomData<Self::TargetU>, Self::Error> {
+        Ok(std::marker::PhantomData)
+    }
 
     fn fold<X: Foldable<U, Self::TargetU>>(&mut self, node: X) -> Result<X::Mapped, Self::Error> {
         node.fold(self)
@@ -73,24 +85,13 @@ pub trait Fold<U> {
     fn fold_pattern(&mut self, node: Pattern<U>) -> Result<Pattern<Self::TargetU>, Self::Error> {
         fold_pattern(self, node)
     }
-    fn fold_type_ignore(&mut self, node: TypeIgnore) -> Result<TypeIgnore, Self::Error> {
+    fn fold_type_ignore(
+        &mut self,
+        node: TypeIgnore<U>,
+    ) -> Result<TypeIgnore<Self::TargetU>, Self::Error> {
         fold_type_ignore(self, node)
     }
 }
-fn fold_attributed<U, F: Fold<U> + ?Sized, T, MT>(
-    folder: &mut F,
-    node: Attributed<T, U>,
-    f: impl FnOnce(&mut F, T) -> Result<MT, F::Error>,
-) -> Result<Attributed<MT, F::TargetU>, F::Error>
-where
-    T: Ranged,
-{
-    let node = folder.map_attributed(node)?;
-    Ok(Attributed {
-        custom: node.custom,
-        node: f(folder, node.node)?,
-    })
-}
 impl<T, U> Foldable<T, U> for Mod<T> {
     type Mapped = Mod<U>;
     fn fold<F: Fold<T, TargetU = U> + ?Sized>(
@@ -106,31 +107,55 @@ pub fn fold_mod<U, F: Fold<U> + ?Sized>(
 ) -> Result<Mod<F::TargetU>, F::Error> {
     match node {
         Mod::Module(ModModule {
-            range,
             body,
             type_ignores,
-        }) => Ok(Mod::Module(ModModule {
-            body: Foldable::fold(body, folder)?,
-            type_ignores: Foldable::fold(type_ignores, folder)?,
-            range,
-        })),
-        Mod::Interactive(ModInteractive { range, body }) => Ok(Mod::Interactive(ModInteractive {
-            body: Foldable::fold(body, folder)?,
-            range,
-        })),
-        Mod::Expression(ModExpression { range, body }) => Ok(Mod::Expression(ModExpression {
-            body: Foldable::fold(body, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            #[cfg(not(feature = "more-attributes"))]
+            let custom = std::marker::PhantomData;
+            #[cfg(feature = "more-attributes")]
+            let custom = folder.map_user(custom)?;
+            Ok(Mod::Module(ModModule {
+                body: Foldable::fold(body, folder)?,
+                type_ignores: Foldable::fold(type_ignores, folder)?,
+                custom,
+            }))
+        }
+        Mod::Interactive(ModInteractive { body, custom }) => {
+            #[cfg(not(feature = "more-attributes"))]
+            let custom = std::marker::PhantomData;
+            #[cfg(feature = "more-attributes")]
+            let custom = folder.map_user(custom)?;
+            Ok(Mod::Interactive(ModInteractive {
+                body: Foldable::fold(body, folder)?,
+                custom,
+            }))
+        }
+        Mod::Expression(ModExpression { body, custom }) => {
+            #[cfg(not(feature = "more-attributes"))]
+            let custom = std::marker::PhantomData;
+            #[cfg(feature = "more-attributes")]
+            let custom = folder.map_user(custom)?;
+            Ok(Mod::Expression(ModExpression {
+                body: Foldable::fold(body, folder)?,
+                custom,
+            }))
+        }
         Mod::FunctionType(ModFunctionType {
-            range,
             argtypes,
             returns,
-        }) => Ok(Mod::FunctionType(ModFunctionType {
-            argtypes: Foldable::fold(argtypes, folder)?,
-            returns: Foldable::fold(returns, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            #[cfg(not(feature = "more-attributes"))]
+            let custom = std::marker::PhantomData;
+            #[cfg(feature = "more-attributes")]
+            let custom = folder.map_user(custom)?;
+            Ok(Mod::FunctionType(ModFunctionType {
+                argtypes: Foldable::fold(argtypes, folder)?,
+                returns: Foldable::fold(returns, folder)?,
+                custom,
+            }))
+        }
     }
 }
 impl<T, U> Foldable<T, U> for Stmt<T> {
@@ -146,249 +171,330 @@ pub fn fold_stmt<U, F: Fold<U> + ?Sized>(
     #[allow(unused)] folder: &mut F,
     node: Stmt<U>,
 ) -> Result<Stmt<F::TargetU>, F::Error> {
-    fold_attributed(folder, node, |folder, node| match node {
+    match node {
         Stmt::FunctionDef(StmtFunctionDef {
-            range,
             name,
             args,
             body,
             decorator_list,
             returns,
             type_comment,
-        }) => Ok(Stmt::FunctionDef(StmtFunctionDef {
-            name: Foldable::fold(name, folder)?,
-            args: Foldable::fold(args, folder)?,
-            body: Foldable::fold(body, folder)?,
-            decorator_list: Foldable::fold(decorator_list, folder)?,
-            returns: Foldable::fold(returns, folder)?,
-            type_comment: Foldable::fold(type_comment, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Stmt::FunctionDef(StmtFunctionDef {
+                name: Foldable::fold(name, folder)?,
+                args: Foldable::fold(args, folder)?,
+                body: Foldable::fold(body, folder)?,
+                decorator_list: Foldable::fold(decorator_list, folder)?,
+                returns: Foldable::fold(returns, folder)?,
+                type_comment: Foldable::fold(type_comment, folder)?,
+                custom,
+            }))
+        }
         Stmt::AsyncFunctionDef(StmtAsyncFunctionDef {
-            range,
             name,
             args,
             body,
             decorator_list,
             returns,
             type_comment,
-        }) => Ok(Stmt::AsyncFunctionDef(StmtAsyncFunctionDef {
-            name: Foldable::fold(name, folder)?,
-            args: Foldable::fold(args, folder)?,
-            body: Foldable::fold(body, folder)?,
-            decorator_list: Foldable::fold(decorator_list, folder)?,
-            returns: Foldable::fold(returns, folder)?,
-            type_comment: Foldable::fold(type_comment, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Stmt::AsyncFunctionDef(StmtAsyncFunctionDef {
+                name: Foldable::fold(name, folder)?,
+                args: Foldable::fold(args, folder)?,
+                body: Foldable::fold(body, folder)?,
+                decorator_list: Foldable::fold(decorator_list, folder)?,
+                returns: Foldable::fold(returns, folder)?,
+                type_comment: Foldable::fold(type_comment, folder)?,
+                custom,
+            }))
+        }
         Stmt::ClassDef(StmtClassDef {
-            range,
             name,
             bases,
             keywords,
             body,
             decorator_list,
-        }) => Ok(Stmt::ClassDef(StmtClassDef {
-            name: Foldable::fold(name, folder)?,
-            bases: Foldable::fold(bases, folder)?,
-            keywords: Foldable::fold(keywords, folder)?,
-            body: Foldable::fold(body, folder)?,
-            decorator_list: Foldable::fold(decorator_list, folder)?,
-            range,
-        })),
-        Stmt::Return(StmtReturn { range, value }) => Ok(Stmt::Return(StmtReturn {
-            value: Foldable::fold(value, folder)?,
-            range,
-        })),
-        Stmt::Delete(StmtDelete { range, targets }) => Ok(Stmt::Delete(StmtDelete {
-            targets: Foldable::fold(targets, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Stmt::ClassDef(StmtClassDef {
+                name: Foldable::fold(name, folder)?,
+                bases: Foldable::fold(bases, folder)?,
+                keywords: Foldable::fold(keywords, folder)?,
+                body: Foldable::fold(body, folder)?,
+                decorator_list: Foldable::fold(decorator_list, folder)?,
+                custom,
+            }))
+        }
+        Stmt::Return(StmtReturn { value, custom }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Stmt::Return(StmtReturn {
+                value: Foldable::fold(value, folder)?,
+                custom,
+            }))
+        }
+        Stmt::Delete(StmtDelete { targets, custom }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Stmt::Delete(StmtDelete {
+                targets: Foldable::fold(targets, folder)?,
+                custom,
+            }))
+        }
         Stmt::Assign(StmtAssign {
-            range,
             targets,
             value,
             type_comment,
-        }) => Ok(Stmt::Assign(StmtAssign {
-            targets: Foldable::fold(targets, folder)?,
-            value: Foldable::fold(value, folder)?,
-            type_comment: Foldable::fold(type_comment, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Stmt::Assign(StmtAssign {
+                targets: Foldable::fold(targets, folder)?,
+                value: Foldable::fold(value, folder)?,
+                type_comment: Foldable::fold(type_comment, folder)?,
+                custom,
+            }))
+        }
         Stmt::AugAssign(StmtAugAssign {
-            range,
             target,
             op,
             value,
-        }) => Ok(Stmt::AugAssign(StmtAugAssign {
-            target: Foldable::fold(target, folder)?,
-            op: Foldable::fold(op, folder)?,
-            value: Foldable::fold(value, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Stmt::AugAssign(StmtAugAssign {
+                target: Foldable::fold(target, folder)?,
+                op: Foldable::fold(op, folder)?,
+                value: Foldable::fold(value, folder)?,
+                custom,
+            }))
+        }
         Stmt::AnnAssign(StmtAnnAssign {
-            range,
             target,
             annotation,
             value,
             simple,
-        }) => Ok(Stmt::AnnAssign(StmtAnnAssign {
-            target: Foldable::fold(target, folder)?,
-            annotation: Foldable::fold(annotation, folder)?,
-            value: Foldable::fold(value, folder)?,
-            simple: Foldable::fold(simple, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Stmt::AnnAssign(StmtAnnAssign {
+                target: Foldable::fold(target, folder)?,
+                annotation: Foldable::fold(annotation, folder)?,
+                value: Foldable::fold(value, folder)?,
+                simple: Foldable::fold(simple, folder)?,
+                custom,
+            }))
+        }
         Stmt::For(StmtFor {
-            range,
             target,
             iter,
             body,
             orelse,
             type_comment,
-        }) => Ok(Stmt::For(StmtFor {
-            target: Foldable::fold(target, folder)?,
-            iter: Foldable::fold(iter, folder)?,
-            body: Foldable::fold(body, folder)?,
-            orelse: Foldable::fold(orelse, folder)?,
-            type_comment: Foldable::fold(type_comment, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Stmt::For(StmtFor {
+                target: Foldable::fold(target, folder)?,
+                iter: Foldable::fold(iter, folder)?,
+                body: Foldable::fold(body, folder)?,
+                orelse: Foldable::fold(orelse, folder)?,
+                type_comment: Foldable::fold(type_comment, folder)?,
+                custom,
+            }))
+        }
         Stmt::AsyncFor(StmtAsyncFor {
-            range,
             target,
             iter,
             body,
             orelse,
             type_comment,
-        }) => Ok(Stmt::AsyncFor(StmtAsyncFor {
-            target: Foldable::fold(target, folder)?,
-            iter: Foldable::fold(iter, folder)?,
-            body: Foldable::fold(body, folder)?,
-            orelse: Foldable::fold(orelse, folder)?,
-            type_comment: Foldable::fold(type_comment, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Stmt::AsyncFor(StmtAsyncFor {
+                target: Foldable::fold(target, folder)?,
+                iter: Foldable::fold(iter, folder)?,
+                body: Foldable::fold(body, folder)?,
+                orelse: Foldable::fold(orelse, folder)?,
+                type_comment: Foldable::fold(type_comment, folder)?,
+                custom,
+            }))
+        }
         Stmt::While(StmtWhile {
-            range,
             test,
             body,
             orelse,
-        }) => Ok(Stmt::While(StmtWhile {
-            test: Foldable::fold(test, folder)?,
-            body: Foldable::fold(body, folder)?,
-            orelse: Foldable::fold(orelse, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Stmt::While(StmtWhile {
+                test: Foldable::fold(test, folder)?,
+                body: Foldable::fold(body, folder)?,
+                orelse: Foldable::fold(orelse, folder)?,
+                custom,
+            }))
+        }
         Stmt::If(StmtIf {
-            range,
             test,
             body,
             orelse,
-        }) => Ok(Stmt::If(StmtIf {
-            test: Foldable::fold(test, folder)?,
-            body: Foldable::fold(body, folder)?,
-            orelse: Foldable::fold(orelse, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Stmt::If(StmtIf {
+                test: Foldable::fold(test, folder)?,
+                body: Foldable::fold(body, folder)?,
+                orelse: Foldable::fold(orelse, folder)?,
+                custom,
+            }))
+        }
         Stmt::With(StmtWith {
-            range,
             items,
             body,
             type_comment,
-        }) => Ok(Stmt::With(StmtWith {
-            items: Foldable::fold(items, folder)?,
-            body: Foldable::fold(body, folder)?,
-            type_comment: Foldable::fold(type_comment, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Stmt::With(StmtWith {
+                items: Foldable::fold(items, folder)?,
+                body: Foldable::fold(body, folder)?,
+                type_comment: Foldable::fold(type_comment, folder)?,
+                custom,
+            }))
+        }
         Stmt::AsyncWith(StmtAsyncWith {
-            range,
             items,
             body,
             type_comment,
-        }) => Ok(Stmt::AsyncWith(StmtAsyncWith {
-            items: Foldable::fold(items, folder)?,
-            body: Foldable::fold(body, folder)?,
-            type_comment: Foldable::fold(type_comment, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Stmt::AsyncWith(StmtAsyncWith {
+                items: Foldable::fold(items, folder)?,
+                body: Foldable::fold(body, folder)?,
+                type_comment: Foldable::fold(type_comment, folder)?,
+                custom,
+            }))
+        }
         Stmt::Match(StmtMatch {
-            range,
             subject,
             cases,
-        }) => Ok(Stmt::Match(StmtMatch {
-            subject: Foldable::fold(subject, folder)?,
-            cases: Foldable::fold(cases, folder)?,
-            range,
-        })),
-        Stmt::Raise(StmtRaise { range, exc, cause }) => Ok(Stmt::Raise(StmtRaise {
-            exc: Foldable::fold(exc, folder)?,
-            cause: Foldable::fold(cause, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Stmt::Match(StmtMatch {
+                subject: Foldable::fold(subject, folder)?,
+                cases: Foldable::fold(cases, folder)?,
+                custom,
+            }))
+        }
+        Stmt::Raise(StmtRaise { exc, cause, custom }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Stmt::Raise(StmtRaise {
+                exc: Foldable::fold(exc, folder)?,
+                cause: Foldable::fold(cause, folder)?,
+                custom,
+            }))
+        }
         Stmt::Try(StmtTry {
-            range,
             body,
             handlers,
             orelse,
             finalbody,
-        }) => Ok(Stmt::Try(StmtTry {
-            body: Foldable::fold(body, folder)?,
-            handlers: Foldable::fold(handlers, folder)?,
-            orelse: Foldable::fold(orelse, folder)?,
-            finalbody: Foldable::fold(finalbody, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Stmt::Try(StmtTry {
+                body: Foldable::fold(body, folder)?,
+                handlers: Foldable::fold(handlers, folder)?,
+                orelse: Foldable::fold(orelse, folder)?,
+                finalbody: Foldable::fold(finalbody, folder)?,
+                custom,
+            }))
+        }
         Stmt::TryStar(StmtTryStar {
-            range,
             body,
             handlers,
             orelse,
             finalbody,
-        }) => Ok(Stmt::TryStar(StmtTryStar {
-            body: Foldable::fold(body, folder)?,
-            handlers: Foldable::fold(handlers, folder)?,
-            orelse: Foldable::fold(orelse, folder)?,
-            finalbody: Foldable::fold(finalbody, folder)?,
-            range,
-        })),
-        Stmt::Assert(StmtAssert { range, test, msg }) => Ok(Stmt::Assert(StmtAssert {
-            test: Foldable::fold(test, folder)?,
-            msg: Foldable::fold(msg, folder)?,
-            range,
-        })),
-        Stmt::Import(StmtImport { range, names }) => Ok(Stmt::Import(StmtImport {
-            names: Foldable::fold(names, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Stmt::TryStar(StmtTryStar {
+                body: Foldable::fold(body, folder)?,
+                handlers: Foldable::fold(handlers, folder)?,
+                orelse: Foldable::fold(orelse, folder)?,
+                finalbody: Foldable::fold(finalbody, folder)?,
+                custom,
+            }))
+        }
+        Stmt::Assert(StmtAssert { test, msg, custom }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Stmt::Assert(StmtAssert {
+                test: Foldable::fold(test, folder)?,
+                msg: Foldable::fold(msg, folder)?,
+                custom,
+            }))
+        }
+        Stmt::Import(StmtImport { names, custom }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Stmt::Import(StmtImport {
+                names: Foldable::fold(names, folder)?,
+                custom,
+            }))
+        }
         Stmt::ImportFrom(StmtImportFrom {
-            range,
             module,
             names,
             level,
-        }) => Ok(Stmt::ImportFrom(StmtImportFrom {
-            module: Foldable::fold(module, folder)?,
-            names: Foldable::fold(names, folder)?,
-            level: Foldable::fold(level, folder)?,
-            range,
-        })),
-        Stmt::Global(StmtGlobal { range, names }) => Ok(Stmt::Global(StmtGlobal {
-            names: Foldable::fold(names, folder)?,
-            range,
-        })),
-        Stmt::Nonlocal(StmtNonlocal { range, names }) => Ok(Stmt::Nonlocal(StmtNonlocal {
-            names: Foldable::fold(names, folder)?,
-            range,
-        })),
-        Stmt::Expr(StmtExpr { range, value }) => Ok(Stmt::Expr(StmtExpr {
-            value: Foldable::fold(value, folder)?,
-            range,
-        })),
-        Stmt::Pass(StmtPass { range }) => Ok(Stmt::Pass(StmtPass { range })),
-        Stmt::Break(StmtBreak { range }) => Ok(Stmt::Break(StmtBreak { range })),
-        Stmt::Continue(StmtContinue { range }) => Ok(Stmt::Continue(StmtContinue { range })),
-    })
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Stmt::ImportFrom(StmtImportFrom {
+                module: Foldable::fold(module, folder)?,
+                names: Foldable::fold(names, folder)?,
+                level: Foldable::fold(level, folder)?,
+                custom,
+            }))
+        }
+        Stmt::Global(StmtGlobal { names, custom }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Stmt::Global(StmtGlobal {
+                names: Foldable::fold(names, folder)?,
+                custom,
+            }))
+        }
+        Stmt::Nonlocal(StmtNonlocal { names, custom }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Stmt::Nonlocal(StmtNonlocal {
+                names: Foldable::fold(names, folder)?,
+                custom,
+            }))
+        }
+        Stmt::Expr(StmtExpr { value, custom }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Stmt::Expr(StmtExpr {
+                value: Foldable::fold(value, folder)?,
+                custom,
+            }))
+        }
+        Stmt::Pass(StmtPass { custom }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Stmt::Pass(StmtPass { custom }))
+        }
+        Stmt::Break(StmtBreak { custom }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Stmt::Break(StmtBreak { custom }))
+        }
+        Stmt::Continue(StmtContinue { custom }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Stmt::Continue(StmtContinue { custom }))
+        }
+    }
 }
 impl<T, U> Foldable<T, U> for Expr<T> {
     type Mapped = Expr<U>;
@@ -403,212 +509,301 @@ pub fn fold_expr<U, F: Fold<U> + ?Sized>(
     #[allow(unused)] folder: &mut F,
     node: Expr<U>,
 ) -> Result<Expr<F::TargetU>, F::Error> {
-    fold_attributed(folder, node, |folder, node| match node {
-        Expr::BoolOp(ExprBoolOp { range, op, values }) => Ok(Expr::BoolOp(ExprBoolOp {
-            op: Foldable::fold(op, folder)?,
-            values: Foldable::fold(values, folder)?,
-            range,
-        })),
+    match node {
+        Expr::BoolOp(ExprBoolOp { op, values, custom }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Expr::BoolOp(ExprBoolOp {
+                op: Foldable::fold(op, folder)?,
+                values: Foldable::fold(values, folder)?,
+                custom,
+            }))
+        }
         Expr::NamedExpr(ExprNamedExpr {
-            range,
             target,
             value,
-        }) => Ok(Expr::NamedExpr(ExprNamedExpr {
-            target: Foldable::fold(target, folder)?,
-            value: Foldable::fold(value, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Expr::NamedExpr(ExprNamedExpr {
+                target: Foldable::fold(target, folder)?,
+                value: Foldable::fold(value, folder)?,
+                custom,
+            }))
+        }
         Expr::BinOp(ExprBinOp {
-            range,
             left,
             op,
             right,
-        }) => Ok(Expr::BinOp(ExprBinOp {
-            left: Foldable::fold(left, folder)?,
-            op: Foldable::fold(op, folder)?,
-            right: Foldable::fold(right, folder)?,
-            range,
-        })),
-        Expr::UnaryOp(ExprUnaryOp { range, op, operand }) => Ok(Expr::UnaryOp(ExprUnaryOp {
-            op: Foldable::fold(op, folder)?,
-            operand: Foldable::fold(operand, folder)?,
-            range,
-        })),
-        Expr::Lambda(ExprLambda { range, args, body }) => Ok(Expr::Lambda(ExprLambda {
-            args: Foldable::fold(args, folder)?,
-            body: Foldable::fold(body, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Expr::BinOp(ExprBinOp {
+                left: Foldable::fold(left, folder)?,
+                op: Foldable::fold(op, folder)?,
+                right: Foldable::fold(right, folder)?,
+                custom,
+            }))
+        }
+        Expr::UnaryOp(ExprUnaryOp {
+            op,
+            operand,
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Expr::UnaryOp(ExprUnaryOp {
+                op: Foldable::fold(op, folder)?,
+                operand: Foldable::fold(operand, folder)?,
+                custom,
+            }))
+        }
+        Expr::Lambda(ExprLambda { args, body, custom }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Expr::Lambda(ExprLambda {
+                args: Foldable::fold(args, folder)?,
+                body: Foldable::fold(body, folder)?,
+                custom,
+            }))
+        }
         Expr::IfExp(ExprIfExp {
-            range,
             test,
             body,
             orelse,
-        }) => Ok(Expr::IfExp(ExprIfExp {
-            test: Foldable::fold(test, folder)?,
-            body: Foldable::fold(body, folder)?,
-            orelse: Foldable::fold(orelse, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Expr::IfExp(ExprIfExp {
+                test: Foldable::fold(test, folder)?,
+                body: Foldable::fold(body, folder)?,
+                orelse: Foldable::fold(orelse, folder)?,
+                custom,
+            }))
+        }
         Expr::Dict(ExprDict {
-            range,
             keys,
             values,
-        }) => Ok(Expr::Dict(ExprDict {
-            keys: Foldable::fold(keys, folder)?,
-            values: Foldable::fold(values, folder)?,
-            range,
-        })),
-        Expr::Set(ExprSet { range, elts }) => Ok(Expr::Set(ExprSet {
-            elts: Foldable::fold(elts, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Expr::Dict(ExprDict {
+                keys: Foldable::fold(keys, folder)?,
+                values: Foldable::fold(values, folder)?,
+                custom,
+            }))
+        }
+        Expr::Set(ExprSet { elts, custom }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Expr::Set(ExprSet {
+                elts: Foldable::fold(elts, folder)?,
+                custom,
+            }))
+        }
         Expr::ListComp(ExprListComp {
-            range,
             elt,
             generators,
-        }) => Ok(Expr::ListComp(ExprListComp {
-            elt: Foldable::fold(elt, folder)?,
-            generators: Foldable::fold(generators, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Expr::ListComp(ExprListComp {
+                elt: Foldable::fold(elt, folder)?,
+                generators: Foldable::fold(generators, folder)?,
+                custom,
+            }))
+        }
         Expr::SetComp(ExprSetComp {
-            range,
             elt,
             generators,
-        }) => Ok(Expr::SetComp(ExprSetComp {
-            elt: Foldable::fold(elt, folder)?,
-            generators: Foldable::fold(generators, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Expr::SetComp(ExprSetComp {
+                elt: Foldable::fold(elt, folder)?,
+                generators: Foldable::fold(generators, folder)?,
+                custom,
+            }))
+        }
         Expr::DictComp(ExprDictComp {
-            range,
             key,
             value,
             generators,
-        }) => Ok(Expr::DictComp(ExprDictComp {
-            key: Foldable::fold(key, folder)?,
-            value: Foldable::fold(value, folder)?,
-            generators: Foldable::fold(generators, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Expr::DictComp(ExprDictComp {
+                key: Foldable::fold(key, folder)?,
+                value: Foldable::fold(value, folder)?,
+                generators: Foldable::fold(generators, folder)?,
+                custom,
+            }))
+        }
         Expr::GeneratorExp(ExprGeneratorExp {
-            range,
             elt,
             generators,
-        }) => Ok(Expr::GeneratorExp(ExprGeneratorExp {
-            elt: Foldable::fold(elt, folder)?,
-            generators: Foldable::fold(generators, folder)?,
-            range,
-        })),
-        Expr::Await(ExprAwait { range, value }) => Ok(Expr::Await(ExprAwait {
-            value: Foldable::fold(value, folder)?,
-            range,
-        })),
-        Expr::Yield(ExprYield { range, value }) => Ok(Expr::Yield(ExprYield {
-            value: Foldable::fold(value, folder)?,
-            range,
-        })),
-        Expr::YieldFrom(ExprYieldFrom { range, value }) => Ok(Expr::YieldFrom(ExprYieldFrom {
-            value: Foldable::fold(value, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Expr::GeneratorExp(ExprGeneratorExp {
+                elt: Foldable::fold(elt, folder)?,
+                generators: Foldable::fold(generators, folder)?,
+                custom,
+            }))
+        }
+        Expr::Await(ExprAwait { value, custom }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Expr::Await(ExprAwait {
+                value: Foldable::fold(value, folder)?,
+                custom,
+            }))
+        }
+        Expr::Yield(ExprYield { value, custom }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Expr::Yield(ExprYield {
+                value: Foldable::fold(value, folder)?,
+                custom,
+            }))
+        }
+        Expr::YieldFrom(ExprYieldFrom { value, custom }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Expr::YieldFrom(ExprYieldFrom {
+                value: Foldable::fold(value, folder)?,
+                custom,
+            }))
+        }
         Expr::Compare(ExprCompare {
-            range,
             left,
             ops,
             comparators,
-        }) => Ok(Expr::Compare(ExprCompare {
-            left: Foldable::fold(left, folder)?,
-            ops: Foldable::fold(ops, folder)?,
-            comparators: Foldable::fold(comparators, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Expr::Compare(ExprCompare {
+                left: Foldable::fold(left, folder)?,
+                ops: Foldable::fold(ops, folder)?,
+                comparators: Foldable::fold(comparators, folder)?,
+                custom,
+            }))
+        }
         Expr::Call(ExprCall {
-            range,
             func,
             args,
             keywords,
-        }) => Ok(Expr::Call(ExprCall {
-            func: Foldable::fold(func, folder)?,
-            args: Foldable::fold(args, folder)?,
-            keywords: Foldable::fold(keywords, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Expr::Call(ExprCall {
+                func: Foldable::fold(func, folder)?,
+                args: Foldable::fold(args, folder)?,
+                keywords: Foldable::fold(keywords, folder)?,
+                custom,
+            }))
+        }
         Expr::FormattedValue(ExprFormattedValue {
-            range,
             value,
             conversion,
             format_spec,
-        }) => Ok(Expr::FormattedValue(ExprFormattedValue {
-            value: Foldable::fold(value, folder)?,
-            conversion: Foldable::fold(conversion, folder)?,
-            format_spec: Foldable::fold(format_spec, folder)?,
-            range,
-        })),
-        Expr::JoinedStr(ExprJoinedStr { range, values }) => Ok(Expr::JoinedStr(ExprJoinedStr {
-            values: Foldable::fold(values, folder)?,
-            range,
-        })),
-        Expr::Constant(ExprConstant { range, value, kind }) => Ok(Expr::Constant(ExprConstant {
-            value: Foldable::fold(value, folder)?,
-            kind: Foldable::fold(kind, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Expr::FormattedValue(ExprFormattedValue {
+                value: Foldable::fold(value, folder)?,
+                conversion: Foldable::fold(conversion, folder)?,
+                format_spec: Foldable::fold(format_spec, folder)?,
+                custom,
+            }))
+        }
+        Expr::JoinedStr(ExprJoinedStr { values, custom }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Expr::JoinedStr(ExprJoinedStr {
+                values: Foldable::fold(values, folder)?,
+                custom,
+            }))
+        }
+        Expr::Constant(ExprConstant {
+            value,
+            kind,
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Expr::Constant(ExprConstant {
+                value: Foldable::fold(value, folder)?,
+                kind: Foldable::fold(kind, folder)?,
+                custom,
+            }))
+        }
         Expr::Attribute(ExprAttribute {
-            range,
             value,
             attr,
             ctx,
-        }) => Ok(Expr::Attribute(ExprAttribute {
-            value: Foldable::fold(value, folder)?,
-            attr: Foldable::fold(attr, folder)?,
-            ctx: Foldable::fold(ctx, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Expr::Attribute(ExprAttribute {
+                value: Foldable::fold(value, folder)?,
+                attr: Foldable::fold(attr, folder)?,
+                ctx: Foldable::fold(ctx, folder)?,
+                custom,
+            }))
+        }
         Expr::Subscript(ExprSubscript {
-            range,
             value,
             slice,
             ctx,
-        }) => Ok(Expr::Subscript(ExprSubscript {
-            value: Foldable::fold(value, folder)?,
-            slice: Foldable::fold(slice, folder)?,
-            ctx: Foldable::fold(ctx, folder)?,
-            range,
-        })),
-        Expr::Starred(ExprStarred { range, value, ctx }) => Ok(Expr::Starred(ExprStarred {
-            value: Foldable::fold(value, folder)?,
-            ctx: Foldable::fold(ctx, folder)?,
-            range,
-        })),
-        Expr::Name(ExprName { range, id, ctx }) => Ok(Expr::Name(ExprName {
-            id: Foldable::fold(id, folder)?,
-            ctx: Foldable::fold(ctx, folder)?,
-            range,
-        })),
-        Expr::List(ExprList { range, elts, ctx }) => Ok(Expr::List(ExprList {
-            elts: Foldable::fold(elts, folder)?,
-            ctx: Foldable::fold(ctx, folder)?,
-            range,
-        })),
-        Expr::Tuple(ExprTuple { range, elts, ctx }) => Ok(Expr::Tuple(ExprTuple {
-            elts: Foldable::fold(elts, folder)?,
-            ctx: Foldable::fold(ctx, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Expr::Subscript(ExprSubscript {
+                value: Foldable::fold(value, folder)?,
+                slice: Foldable::fold(slice, folder)?,
+                ctx: Foldable::fold(ctx, folder)?,
+                custom,
+            }))
+        }
+        Expr::Starred(ExprStarred { value, ctx, custom }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Expr::Starred(ExprStarred {
+                value: Foldable::fold(value, folder)?,
+                ctx: Foldable::fold(ctx, folder)?,
+                custom,
+            }))
+        }
+        Expr::Name(ExprName { id, ctx, custom }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Expr::Name(ExprName {
+                id: Foldable::fold(id, folder)?,
+                ctx: Foldable::fold(ctx, folder)?,
+                custom,
+            }))
+        }
+        Expr::List(ExprList { elts, ctx, custom }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Expr::List(ExprList {
+                elts: Foldable::fold(elts, folder)?,
+                ctx: Foldable::fold(ctx, folder)?,
+                custom,
+            }))
+        }
+        Expr::Tuple(ExprTuple { elts, ctx, custom }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Expr::Tuple(ExprTuple {
+                elts: Foldable::fold(elts, folder)?,
+                ctx: Foldable::fold(ctx, folder)?,
+                custom,
+            }))
+        }
         Expr::Slice(ExprSlice {
-            range,
             lower,
             upper,
             step,
-        }) => Ok(Expr::Slice(ExprSlice {
-            lower: Foldable::fold(lower, folder)?,
-            upper: Foldable::fold(upper, folder)?,
-            step: Foldable::fold(step, folder)?,
-            range,
-        })),
-    })
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Expr::Slice(ExprSlice {
+                lower: Foldable::fold(lower, folder)?,
+                upper: Foldable::fold(upper, folder)?,
+                step: Foldable::fold(step, folder)?,
+                custom,
+            }))
+        }
+    }
 }
 impl<T, U> Foldable<T, U> for ExprContext {
     type Mapped = ExprContext;
@@ -623,11 +818,7 @@ pub fn fold_expr_context<U, F: Fold<U> + ?Sized>(
     #[allow(unused)] folder: &mut F,
     node: ExprContext,
 ) -> Result<ExprContext, F::Error> {
-    match node {
-        ExprContext::Load {} => Ok(ExprContext::Load {}),
-        ExprContext::Store {} => Ok(ExprContext::Store {}),
-        ExprContext::Del {} => Ok(ExprContext::Del {}),
-    }
+    Ok(node)
 }
 impl<T, U> Foldable<T, U> for Boolop {
     type Mapped = Boolop;
@@ -642,10 +833,7 @@ pub fn fold_boolop<U, F: Fold<U> + ?Sized>(
     #[allow(unused)] folder: &mut F,
     node: Boolop,
 ) -> Result<Boolop, F::Error> {
-    match node {
-        Boolop::And {} => Ok(Boolop::And {}),
-        Boolop::Or {} => Ok(Boolop::Or {}),
-    }
+    Ok(node)
 }
 impl<T, U> Foldable<T, U> for Operator {
     type Mapped = Operator;
@@ -660,21 +848,7 @@ pub fn fold_operator<U, F: Fold<U> + ?Sized>(
     #[allow(unused)] folder: &mut F,
     node: Operator,
 ) -> Result<Operator, F::Error> {
-    match node {
-        Operator::Add {} => Ok(Operator::Add {}),
-        Operator::Sub {} => Ok(Operator::Sub {}),
-        Operator::Mult {} => Ok(Operator::Mult {}),
-        Operator::MatMult {} => Ok(Operator::MatMult {}),
-        Operator::Div {} => Ok(Operator::Div {}),
-        Operator::Mod {} => Ok(Operator::Mod {}),
-        Operator::Pow {} => Ok(Operator::Pow {}),
-        Operator::LShift {} => Ok(Operator::LShift {}),
-        Operator::RShift {} => Ok(Operator::RShift {}),
-        Operator::BitOr {} => Ok(Operator::BitOr {}),
-        Operator::BitXor {} => Ok(Operator::BitXor {}),
-        Operator::BitAnd {} => Ok(Operator::BitAnd {}),
-        Operator::FloorDiv {} => Ok(Operator::FloorDiv {}),
-    }
+    Ok(node)
 }
 impl<T, U> Foldable<T, U> for Unaryop {
     type Mapped = Unaryop;
@@ -689,12 +863,7 @@ pub fn fold_unaryop<U, F: Fold<U> + ?Sized>(
     #[allow(unused)] folder: &mut F,
     node: Unaryop,
 ) -> Result<Unaryop, F::Error> {
-    match node {
-        Unaryop::Invert {} => Ok(Unaryop::Invert {}),
-        Unaryop::Not {} => Ok(Unaryop::Not {}),
-        Unaryop::UAdd {} => Ok(Unaryop::UAdd {}),
-        Unaryop::USub {} => Ok(Unaryop::USub {}),
-    }
+    Ok(node)
 }
 impl<T, U> Foldable<T, U> for Cmpop {
     type Mapped = Cmpop;
@@ -709,18 +878,7 @@ pub fn fold_cmpop<U, F: Fold<U> + ?Sized>(
     #[allow(unused)] folder: &mut F,
     node: Cmpop,
 ) -> Result<Cmpop, F::Error> {
-    match node {
-        Cmpop::Eq {} => Ok(Cmpop::Eq {}),
-        Cmpop::NotEq {} => Ok(Cmpop::NotEq {}),
-        Cmpop::Lt {} => Ok(Cmpop::Lt {}),
-        Cmpop::LtE {} => Ok(Cmpop::LtE {}),
-        Cmpop::Gt {} => Ok(Cmpop::Gt {}),
-        Cmpop::GtE {} => Ok(Cmpop::GtE {}),
-        Cmpop::Is {} => Ok(Cmpop::Is {}),
-        Cmpop::IsNot {} => Ok(Cmpop::IsNot {}),
-        Cmpop::In {} => Ok(Cmpop::In {}),
-        Cmpop::NotIn {} => Ok(Cmpop::NotIn {}),
-    }
+    Ok(node)
 }
 impl<T, U> Foldable<T, U> for Comprehension<T> {
     type Mapped = Comprehension<U>;
@@ -736,18 +894,22 @@ pub fn fold_comprehension<U, F: Fold<U> + ?Sized>(
     node: Comprehension<U>,
 ) -> Result<Comprehension<F::TargetU>, F::Error> {
     let Comprehension {
-        range,
         target,
         iter,
         ifs,
         is_async,
+        custom,
     } = node;
+    #[cfg(not(feature = "more-attributes"))]
+    let custom = std::marker::PhantomData;
+    #[cfg(feature = "more-attributes")]
+    let custom = folder.map_user(custom)?;
     Ok(Comprehension {
         target: Foldable::fold(target, folder)?,
         iter: Foldable::fold(iter, folder)?,
         ifs: Foldable::fold(ifs, folder)?,
         is_async: Foldable::fold(is_async, folder)?,
-        range,
+        custom,
     })
 }
 impl<T, U> Foldable<T, U> for Excepthandler<T> {
@@ -763,19 +925,22 @@ pub fn fold_excepthandler<U, F: Fold<U> + ?Sized>(
     #[allow(unused)] folder: &mut F,
     node: Excepthandler<U>,
 ) -> Result<Excepthandler<F::TargetU>, F::Error> {
-    fold_attributed(folder, node, |folder, node| match node {
+    match node {
         Excepthandler::ExceptHandler(ExcepthandlerExceptHandler {
-            range,
             type_,
             name,
             body,
-        }) => Ok(Excepthandler::ExceptHandler(ExcepthandlerExceptHandler {
-            type_: Foldable::fold(type_, folder)?,
-            name: Foldable::fold(name, folder)?,
-            body: Foldable::fold(body, folder)?,
-            range,
-        })),
-    })
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Excepthandler::ExceptHandler(ExcepthandlerExceptHandler {
+                type_: Foldable::fold(type_, folder)?,
+                name: Foldable::fold(name, folder)?,
+                body: Foldable::fold(body, folder)?,
+                custom,
+            }))
+        }
+    }
 }
 impl<T, U> Foldable<T, U> for Arguments<T> {
     type Mapped = Arguments<U>;
@@ -791,7 +956,6 @@ pub fn fold_arguments<U, F: Fold<U> + ?Sized>(
     node: Arguments<U>,
 ) -> Result<Arguments<F::TargetU>, F::Error> {
     let Arguments {
-        range,
         posonlyargs,
         args,
         vararg,
@@ -799,7 +963,12 @@ pub fn fold_arguments<U, F: Fold<U> + ?Sized>(
         kw_defaults,
         kwarg,
         defaults,
+        custom,
     } = node;
+    #[cfg(not(feature = "more-attributes"))]
+    let custom = std::marker::PhantomData;
+    #[cfg(feature = "more-attributes")]
+    let custom = folder.map_user(custom)?;
     Ok(Arguments {
         posonlyargs: Foldable::fold(posonlyargs, folder)?,
         args: Foldable::fold(args, folder)?,
@@ -808,7 +977,7 @@ pub fn fold_arguments<U, F: Fold<U> + ?Sized>(
         kw_defaults: Foldable::fold(kw_defaults, folder)?,
         kwarg: Foldable::fold(kwarg, folder)?,
         defaults: Foldable::fold(defaults, folder)?,
-        range,
+        custom,
     })
 }
 impl<T, U> Foldable<T, U> for Arg<T> {
@@ -824,19 +993,18 @@ pub fn fold_arg<U, F: Fold<U> + ?Sized>(
     #[allow(unused)] folder: &mut F,
     node: Arg<U>,
 ) -> Result<Arg<F::TargetU>, F::Error> {
-    fold_attributed(folder, node, |folder, node| {
-        let ArgData {
-            range,
-            arg,
-            annotation,
-            type_comment,
-        } = node;
-        Ok(ArgData {
-            arg: Foldable::fold(arg, folder)?,
-            annotation: Foldable::fold(annotation, folder)?,
-            type_comment: Foldable::fold(type_comment, folder)?,
-            range,
-        })
+    let Arg {
+        arg,
+        annotation,
+        type_comment,
+        custom,
+    } = node;
+    let custom = folder.map_user(custom)?;
+    Ok(Arg {
+        arg: Foldable::fold(arg, folder)?,
+        annotation: Foldable::fold(annotation, folder)?,
+        type_comment: Foldable::fold(type_comment, folder)?,
+        custom,
     })
 }
 impl<T, U> Foldable<T, U> for Keyword<T> {
@@ -852,13 +1020,12 @@ pub fn fold_keyword<U, F: Fold<U> + ?Sized>(
     #[allow(unused)] folder: &mut F,
     node: Keyword<U>,
 ) -> Result<Keyword<F::TargetU>, F::Error> {
-    fold_attributed(folder, node, |folder, node| {
-        let KeywordData { range, arg, value } = node;
-        Ok(KeywordData {
-            arg: Foldable::fold(arg, folder)?,
-            value: Foldable::fold(value, folder)?,
-            range,
-        })
+    let Keyword { arg, value, custom } = node;
+    let custom = folder.map_user(custom)?;
+    Ok(Keyword {
+        arg: Foldable::fold(arg, folder)?,
+        value: Foldable::fold(value, folder)?,
+        custom,
     })
 }
 impl<T, U> Foldable<T, U> for Alias<T> {
@@ -874,17 +1041,16 @@ pub fn fold_alias<U, F: Fold<U> + ?Sized>(
     #[allow(unused)] folder: &mut F,
     node: Alias<U>,
 ) -> Result<Alias<F::TargetU>, F::Error> {
-    fold_attributed(folder, node, |folder, node| {
-        let AliasData {
-            range,
-            name,
-            asname,
-        } = node;
-        Ok(AliasData {
-            name: Foldable::fold(name, folder)?,
-            asname: Foldable::fold(asname, folder)?,
-            range,
-        })
+    let Alias {
+        name,
+        asname,
+        custom,
+    } = node;
+    let custom = folder.map_user(custom)?;
+    Ok(Alias {
+        name: Foldable::fold(name, folder)?,
+        asname: Foldable::fold(asname, folder)?,
+        custom,
     })
 }
 impl<T, U> Foldable<T, U> for Withitem<T> {
@@ -901,14 +1067,18 @@ pub fn fold_withitem<U, F: Fold<U> + ?Sized>(
     node: Withitem<U>,
 ) -> Result<Withitem<F::TargetU>, F::Error> {
     let Withitem {
-        range,
         context_expr,
         optional_vars,
+        custom,
     } = node;
+    #[cfg(not(feature = "more-attributes"))]
+    let custom = std::marker::PhantomData;
+    #[cfg(feature = "more-attributes")]
+    let custom = folder.map_user(custom)?;
     Ok(Withitem {
         context_expr: Foldable::fold(context_expr, folder)?,
         optional_vars: Foldable::fold(optional_vars, folder)?,
-        range,
+        custom,
     })
 }
 impl<T, U> Foldable<T, U> for MatchCase<T> {
@@ -925,16 +1095,20 @@ pub fn fold_match_case<U, F: Fold<U> + ?Sized>(
     node: MatchCase<U>,
 ) -> Result<MatchCase<F::TargetU>, F::Error> {
     let MatchCase {
-        range,
         pattern,
         guard,
         body,
+        custom,
     } = node;
+    #[cfg(not(feature = "more-attributes"))]
+    let custom = std::marker::PhantomData;
+    #[cfg(feature = "more-attributes")]
+    let custom = folder.map_user(custom)?;
     Ok(MatchCase {
         pattern: Foldable::fold(pattern, folder)?,
         guard: Foldable::fold(guard, folder)?,
         body: Foldable::fold(body, folder)?,
-        range,
+        custom,
     })
 }
 impl<T, U> Foldable<T, U> for Pattern<T> {
@@ -950,74 +1124,88 @@ pub fn fold_pattern<U, F: Fold<U> + ?Sized>(
     #[allow(unused)] folder: &mut F,
     node: Pattern<U>,
 ) -> Result<Pattern<F::TargetU>, F::Error> {
-    fold_attributed(folder, node, |folder, node| match node {
-        Pattern::MatchValue(PatternMatchValue { range, value }) => {
+    match node {
+        Pattern::MatchValue(PatternMatchValue { value, custom }) => {
+            let custom = folder.map_user(custom)?;
             Ok(Pattern::MatchValue(PatternMatchValue {
                 value: Foldable::fold(value, folder)?,
-                range,
+                custom,
             }))
         }
-        Pattern::MatchSingleton(PatternMatchSingleton { range, value }) => {
+        Pattern::MatchSingleton(PatternMatchSingleton { value, custom }) => {
+            let custom = folder.map_user(custom)?;
             Ok(Pattern::MatchSingleton(PatternMatchSingleton {
                 value: Foldable::fold(value, folder)?,
-                range,
+                custom,
             }))
         }
-        Pattern::MatchSequence(PatternMatchSequence { range, patterns }) => {
+        Pattern::MatchSequence(PatternMatchSequence { patterns, custom }) => {
+            let custom = folder.map_user(custom)?;
             Ok(Pattern::MatchSequence(PatternMatchSequence {
                 patterns: Foldable::fold(patterns, folder)?,
-                range,
+                custom,
             }))
         }
         Pattern::MatchMapping(PatternMatchMapping {
-            range,
             keys,
             patterns,
             rest,
-        }) => Ok(Pattern::MatchMapping(PatternMatchMapping {
-            keys: Foldable::fold(keys, folder)?,
-            patterns: Foldable::fold(patterns, folder)?,
-            rest: Foldable::fold(rest, folder)?,
-            range,
-        })),
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Pattern::MatchMapping(PatternMatchMapping {
+                keys: Foldable::fold(keys, folder)?,
+                patterns: Foldable::fold(patterns, folder)?,
+                rest: Foldable::fold(rest, folder)?,
+                custom,
+            }))
+        }
         Pattern::MatchClass(PatternMatchClass {
-            range,
             cls,
             patterns,
             kwd_attrs,
             kwd_patterns,
-        }) => Ok(Pattern::MatchClass(PatternMatchClass {
-            cls: Foldable::fold(cls, folder)?,
-            patterns: Foldable::fold(patterns, folder)?,
-            kwd_attrs: Foldable::fold(kwd_attrs, folder)?,
-            kwd_patterns: Foldable::fold(kwd_patterns, folder)?,
-            range,
-        })),
-        Pattern::MatchStar(PatternMatchStar { range, name }) => {
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Pattern::MatchClass(PatternMatchClass {
+                cls: Foldable::fold(cls, folder)?,
+                patterns: Foldable::fold(patterns, folder)?,
+                kwd_attrs: Foldable::fold(kwd_attrs, folder)?,
+                kwd_patterns: Foldable::fold(kwd_patterns, folder)?,
+                custom,
+            }))
+        }
+        Pattern::MatchStar(PatternMatchStar { name, custom }) => {
+            let custom = folder.map_user(custom)?;
             Ok(Pattern::MatchStar(PatternMatchStar {
                 name: Foldable::fold(name, folder)?,
-                range,
+                custom,
             }))
         }
         Pattern::MatchAs(PatternMatchAs {
-            range,
             pattern,
             name,
-        }) => Ok(Pattern::MatchAs(PatternMatchAs {
-            pattern: Foldable::fold(pattern, folder)?,
-            name: Foldable::fold(name, folder)?,
-            range,
-        })),
-        Pattern::MatchOr(PatternMatchOr { range, patterns }) => {
-            Ok(Pattern::MatchOr(PatternMatchOr {
-                patterns: Foldable::fold(patterns, folder)?,
-                range,
+            custom,
+        }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Pattern::MatchAs(PatternMatchAs {
+                pattern: Foldable::fold(pattern, folder)?,
+                name: Foldable::fold(name, folder)?,
+                custom,
             }))
         }
-    })
+        Pattern::MatchOr(PatternMatchOr { patterns, custom }) => {
+            let custom = folder.map_user(custom)?;
+            Ok(Pattern::MatchOr(PatternMatchOr {
+                patterns: Foldable::fold(patterns, folder)?,
+                custom,
+            }))
+        }
+    }
 }
-impl<T, U> Foldable<T, U> for TypeIgnore {
-    type Mapped = TypeIgnore;
+impl<T, U> Foldable<T, U> for TypeIgnore<T> {
+    type Mapped = TypeIgnore<U>;
     fn fold<F: Fold<T, TargetU = U> + ?Sized>(
         self,
         folder: &mut F,
@@ -1027,14 +1215,22 @@ impl<T, U> Foldable<T, U> for TypeIgnore {
 }
 pub fn fold_type_ignore<U, F: Fold<U> + ?Sized>(
     #[allow(unused)] folder: &mut F,
-    node: TypeIgnore,
-) -> Result<TypeIgnore, F::Error> {
+    node: TypeIgnore<U>,
+) -> Result<TypeIgnore<F::TargetU>, F::Error> {
     match node {
-        TypeIgnore::TypeIgnore(TypeIgnoreTypeIgnore { range, lineno, tag }) => {
+        TypeIgnore::TypeIgnore(TypeIgnoreTypeIgnore {
+            lineno,
+            tag,
+            custom,
+        }) => {
+            #[cfg(not(feature = "more-attributes"))]
+            let custom = std::marker::PhantomData;
+            #[cfg(feature = "more-attributes")]
+            let custom = folder.map_user(custom)?;
             Ok(TypeIgnore::TypeIgnore(TypeIgnoreTypeIgnore {
                 lineno: Foldable::fold(lineno, folder)?,
                 tag: Foldable::fold(tag, folder)?,
-                range,
+                custom,
             }))
         }
     }
diff --git a/ast/src/gen/visitor.rs b/ast/src/gen/visitor.rs
index b7ea5db..fad52fe 100644
--- a/ast/src/gen/visitor.rs
+++ b/ast/src/gen/visitor.rs
@@ -7,33 +7,33 @@ pub trait Visitor<U = ()> {
     }
     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(data) => self.visit_stmt_Pass(data),
-            StmtKind::Break(data) => self.visit_stmt_Break(data),
-            StmtKind::Continue(data) => self.visit_stmt_Continue(data),
+            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) {
@@ -346,33 +346,33 @@ pub trait Visitor<U = ()> {
     }
     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),
+            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) {
@@ -690,7 +690,7 @@ pub trait Visitor<U = ()> {
     }
     fn generic_visit_excepthandler(&mut self, node: Excepthandler) {
         match node.node {
-            ExcepthandlerKind::ExceptHandler(data) => self.visit_excepthandler_ExceptHandler(data),
+            Excepthandler::ExceptHandler(data) => self.visit_excepthandler_ExceptHandler(data),
         }
     }
     fn visit_excepthandler_ExceptHandler(&mut self, node: ExcepthandlerExceptHandler) {
@@ -733,14 +733,14 @@ pub trait Visitor<U = ()> {
     }
     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),
+            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) {
diff --git a/ast/src/located.rs b/ast/src/located.rs
index 655b52a..ea628bf 100644
--- a/ast/src/located.rs
+++ b/ast/src/located.rs
@@ -5,11 +5,11 @@ pub trait Located {
     fn range(&self) -> SourceRange;
 
     fn location(&self) -> SourceLocation {
-        self.range().start()
+        self.range().start
     }
 
-    fn end_location(&self) -> SourceLocation {
-        self.range().end()
+    fn end_location(&self) -> Option<SourceLocation> {
+        self.range().end
     }
 }
 
diff --git a/ast/src/source_locator.rs b/ast/src/source_locator.rs
index 3152ebb..ebacd89 100644
--- a/ast/src/source_locator.rs
+++ b/ast/src/source_locator.rs
@@ -1,42 +1,15 @@
-use crate::builtin::Attributed;
-use crate::Ranged;
-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>
-    where
-        T: Ranged,
-    {
-        let start = self.locate(node.start());
-        let end = self.locate(node.end());
-        Ok(Attributed {
-            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())
     }
 }